1 package org.onap.sdnc.northbound;
3 import java.text.DateFormat;
4 import java.text.SimpleDateFormat;
6 import java.util.Optional;
7 import java.util.Properties;
8 import java.util.TimeZone;
9 import java.util.concurrent.ExecutionException;
10 import java.util.concurrent.ExecutorService;
11 import java.util.concurrent.Executors;
13 import com.google.common.util.concurrent.FluentFuture;
14 import com.google.common.util.concurrent.Futures;
15 import com.google.common.util.concurrent.ListenableFuture;
17 import org.eclipse.jdt.annotation.NonNull;
18 import org.opendaylight.mdsal.binding.api.DataBroker;
19 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
20 import org.opendaylight.mdsal.binding.api.ReadTransaction;
21 import org.opendaylight.mdsal.binding.api.RpcProviderService;
22 import org.opendaylight.mdsal.binding.api.WriteTransaction;
23 import org.opendaylight.mdsal.common.api.CommitInfo;
24 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
25 import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
26 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.*;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.connection.attachment.response.information.ConnectionAttachmentResponseInformationBuilder;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.gc.response.information.GcResponseInformationBuilder;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.pnf.response.information.PnfResponseInformationBuilder;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.port.mirror.response.information.PortMirrorResponseInformationBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadList;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListKey;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vf.module.response.information.VfModuleResponseInformationBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vnf.response.information.VnfResponseInformationBuilder;
56 import org.opendaylight.yangtools.concepts.ObjectRegistration;
57 import org.opendaylight.yangtools.yang.binding.DataObject;
58 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
59 import org.opendaylight.yangtools.yang.common.RpcResult;
60 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
61 import org.slf4j.Logger;
62 import org.slf4j.LoggerFactory;
65 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
66 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
67 * initialization / clean up methods.
69 * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule class which is
70 * auto generated under src/main/java in this project (created only once during first compilation):
75 * public java.lang.AutoCloseable createInstance() {
77 * // final GENERIC-RESOURCE-APIProvider provider = new
78 * // GENERIC-RESOURCE-APIProvider();
79 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
80 * provider.setDataBroker(getDataBrokerDependency());
81 * provider.setNotificationService(getNotificationServiceDependency());
82 * provider.setRpcService(getRpcServiceDependency());
83 * provider.initialize();
84 * return new AutoCloseable() {
87 * public void close() throws Exception {
88 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
89 * // BROKER/NOTIFICATION
90 * // SERVIE/RPC REGISTRY
99 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
101 protected static final String APP_NAME = "generic-resource-api";
102 private static final String CALLED_STR = "{} called.";
103 private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
104 protected static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
105 private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
106 private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
107 private static final String OPERATIONAL_DATA_PARAM = "operational-data";
108 protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
109 private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
110 private static final String ERROR_CODE_PARAM = "error-code";
111 private static final String ERROR_MESSAGE_PARAM = "error-message";
112 private static final String ACK_FINAL_PARAM = "ack-final";
113 private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
114 private static final String NETWORK_OBJECT_PATH_PARAM = "network-object-path";
115 private static final String VNF_OBJECT_PATH_PARAM = "vnf-object-path";
116 private static final String PNF_OBJECT_PATH_PARAM = "pnf-object-path";
117 private static final String VF_MODULE_OBJECT_PATH_PARAM = "vf-module-object-path";
118 private static final String VF_MODULE_ID_PARAM = "vf-module-id";
119 private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
120 private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
121 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
122 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
123 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
124 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
125 private static final String NON_NULL_PARAM = "non-null";
126 private static final String NULL_PARAM = "null";
127 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
128 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
129 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
130 protected static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
131 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
132 private static final String ERROR_NETWORK_ID = "error";
133 private static final String BACKGROUND_THREAD_STARTED_MESSAGE = "Start background thread";
134 private static final String BACKGROUND_THREAD_INFO = "Background thread: input conf_id is {}";
135 private static final String SKIP_MDSAL_UPDATE_PROP = "skip-mdsal-update";
137 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
138 private final ExecutorService executor;
139 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
141 protected DataBroker dataBroker;
142 protected NotificationPublishService notificationService;
143 protected RpcProviderService rpcService;
144 protected ObjectRegistration<GENERICRESOURCEAPIService> rpcRegistration;
146 public GenericResourceApiProvider(DataBroker dataBroker, NotificationPublishService notificationPublishService,
147 RpcProviderService rpcProviderService, GenericResourceApiSvcLogicServiceClient client) {
148 log.info("Creating provider for {}", APP_NAME);
149 executor = Executors.newFixedThreadPool(1);
150 setDataBroker(dataBroker);
151 setNotificationService(notificationPublishService);
152 setRpcService(rpcProviderService);
153 svcLogicClient = client;
158 public void initialize() {
159 log.info("Initializing provider for {}", APP_NAME);
160 // Create the top level containers
163 GenericResourceApiUtil.loadProperties();
164 } catch (Exception e) {
165 log.error("Caught Exception while trying to load properties file", e);
168 if (rpcRegistration == null) {
169 if (rpcService != null) {
170 rpcRegistration = rpcService.registerRpcImplementation(GENERICRESOURCEAPIService.class, this);
174 log.info("Initialization complete for {}", APP_NAME);
177 protected void initializeChild() {
178 // Override if you have custom initialization intelligence
182 public void close() throws Exception {
183 log.info("Closing provider for {}", APP_NAME);
185 rpcRegistration.close();
186 log.info("Successfully closed provider for {}", APP_NAME);
189 private static class Iso8601Util {
191 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
192 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
194 private Iso8601Util() {
198 dateFormat.setTimeZone(timeZone);
201 private static String now() {
202 return dateFormat.format(new Date());
206 public void setDataBroker(DataBroker dataBroker) {
207 this.dataBroker = dataBroker;
208 if (log.isDebugEnabled()) {
209 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
213 public void setNotificationService(NotificationPublishService notificationService) {
214 this.notificationService = notificationService;
215 if (log.isDebugEnabled()) {
216 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
220 public void setRpcService(RpcProviderService rpcService) {
221 this.rpcService = rpcService;
222 if (log.isDebugEnabled()) {
223 log.debug("rpcService set to {}", rpcService == null ? NULL_PARAM : NON_NULL_PARAM);
227 private void createContainers() {
229 final WriteTransaction t = dataBroker.newReadWriteTransaction();
231 // Create the service-instance container
232 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
233 new ServicesBuilder().build());
234 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
235 new ServicesBuilder().build());
237 // Create the PreloadInformation container
238 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadInformation.class),
239 new PreloadInformationBuilder().build());
240 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadInformation.class),
241 new PreloadInformationBuilder().build());
244 FluentFuture<? extends @NonNull CommitInfo> checkedFuture = t.commit();
246 log.info("Create containers succeeded!");
248 } catch (InterruptedException | ExecutionException e) {
249 log.error("Create containers failed: ", e);
253 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
255 serviceStatusBuilder.setResponseCode(errorCode);
256 serviceStatusBuilder.setResponseMessage(errorMessage);
257 serviceStatusBuilder.setFinalIndicator(ackFinal);
258 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
261 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
262 if (requestInformation != null && requestInformation.getRequestAction() != null) {
263 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
267 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
268 if (requestHeader != null && requestHeader.getSvcAction() != null) {
269 switch (requestHeader.getSvcAction()) {
271 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
274 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
277 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
280 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
283 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
286 serviceStatusBuilder.setRpcAction(RpcAction.Create);
289 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
295 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
297 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
300 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
301 // See if any data exists yet for this siid, if so grab it.
302 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier.<Services>builder(Services.class)
303 .child(Service.class, new ServiceKey(siid)).build();
305 Optional<Service> data = null;
307 try (final ReadTransaction readTx = dataBroker.newReadOnlyTransaction()) {
308 data = (Optional<Service>) readTx.read(type, serviceInstanceIdentifier).get();
309 } catch (final InterruptedException | ExecutionException e) {
310 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
313 if (data != null && data.isPresent()) {
314 ServiceData serviceData = data.get().getServiceData();
315 if (serviceData != null) {
316 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
317 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
318 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
319 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
320 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
321 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
322 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
323 serviceDataBuilder.setNetworks(serviceData.getNetworks());
324 serviceDataBuilder.setVnfs(serviceData.getVnfs());
325 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
326 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
327 serviceDataBuilder.setNetworkInstanceGroups(serviceData.getNetworkInstanceGroups());
328 serviceDataBuilder.setVnfcInstanceGroups(serviceData.getVnfcInstanceGroups());
329 serviceDataBuilder.setForwardingPaths(serviceData.getForwardingPaths());
330 serviceDataBuilder.setProvidedConfigurations(serviceData.getProvidedConfigurations());
331 // service-instance-id needs to be set
333 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
336 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
340 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
341 // Each entry will be identifiable by a unique key, we have to create that
343 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
344 .child(Service.class, entry.key()).build();
346 trySaveEntry(entry, merge, storeType, path);
349 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
350 InstanceIdentifier<T> path) {
354 save(entry, merge, storeType, path);
356 } catch (OptimisticLockFailedException e) {
358 log.debug("Got OptimisticLockFailedException on last try - failing ");
359 throw new IllegalStateException(e);
361 log.debug("Got OptimisticLockFailedException - trying again ");
362 } catch (TransactionCommitFailedException|InterruptedException|ExecutionException ex) {
363 log.debug("Update DataStore failed");
364 throw new IllegalStateException(ex);
369 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
370 InstanceIdentifier<T> path) throws TransactionCommitFailedException, InterruptedException,
372 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
374 tx.merge(storeType, path, entry);
376 tx.put(storeType, path, entry);
379 log.debug("Update DataStore succeeded");
382 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
383 // Each entry will be identifiable by a unique key, we have to create
385 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
386 .child(Service.class, entry.key()).build();
388 tryDeleteEntry(storeType, path);
391 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
395 delete(storeType, path);
397 } catch (OptimisticLockFailedException e) {
399 log.debug("Got OptimisticLockFailedException on last try - failing ");
400 throw new IllegalStateException(e);
402 log.debug("Got OptimisticLockFailedException - trying again ");
403 } catch (TransactionCommitFailedException|InterruptedException|ExecutionException ex) {
404 log.debug("Update DataStore failed");
405 throw new IllegalStateException(ex);
410 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
411 throws TransactionCommitFailedException, InterruptedException, ExecutionException {
412 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
413 tx.delete(storeType, path);
415 log.debug("DataStore delete succeeded");
418 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
420 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
423 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
424 LogicalDatastoreType type) {
425 // See if any data exists yet for this name/type, if so grab it.
426 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier
427 .<PreloadInformation>builder(PreloadInformation.class)
428 .child(PreloadList.class, new PreloadListKey(preloadName, preloadType)).build();
430 Optional<PreloadList> data = null;
431 try (final ReadTransaction readTx = dataBroker.newReadOnlyTransaction()) {
432 data = (Optional<PreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
433 } catch (final InterruptedException | ExecutionException e) {
434 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
437 if (data != null && data.isPresent()) {
438 PreloadData preloadData = data.get().getPreloadData();
439 if (preloadData != null) {
440 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
443 .setPreloadVfModuleTopologyInformation(preloadData.getPreloadVfModuleTopologyInformation());
445 .setPreloadNetworkTopologyInformation(preloadData.getPreloadNetworkTopologyInformation());
446 preloadDataBuilder.setPreloadOperStatus(preloadData.getPreloadOperStatus());
448 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
451 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
455 private void savePreloadList(final PreloadList entry, boolean merge, LogicalDatastoreType storeType)
456 throws IllegalStateException {
458 // Each entry will be identifiable by a unique key, we have to create that
460 InstanceIdentifier.InstanceIdentifierBuilder<PreloadList> preloadListBuilder = InstanceIdentifier
461 .<PreloadInformation>builder(PreloadInformation.class).child(PreloadList.class, entry.key());
462 InstanceIdentifier<PreloadList> path = preloadListBuilder.build();
466 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
468 tx.merge(storeType, path, entry);
470 tx.put(storeType, path, entry);
473 log.debug("Update DataStore succeeded");
475 } catch (final InterruptedException | ExecutionException e) {
476 if (e instanceof OptimisticLockFailedException) {
478 log.debug("Got OptimisticLockFailedException on last try - failing ");
479 throw new IllegalStateException(e);
481 log.debug("Got OptimisticLockFailedException - trying again ");
483 log.debug("Update DataStore failed");
484 throw new IllegalStateException(e);
490 private void deletePreloadList(final PreloadList entry, LogicalDatastoreType storeType) {
491 // Each entry will be identifiable by a unique key, we have to create
493 InstanceIdentifier<PreloadList> path = InstanceIdentifier.builder(PreloadInformation.class)
494 .child(PreloadList.class, entry.key()).build();
496 tryDeletePreloadListEntry(storeType, path);
499 private void tryDeletePreloadListEntry(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path) {
503 deletePreloadList(storeType, path);
505 } catch (OptimisticLockFailedException e) {
507 log.debug("Got OptimisticLockFailedException on last try - failing ");
508 throw new IllegalStateException(e);
510 log.debug("Got OptimisticLockFailedException - trying again ");
511 } catch (TransactionCommitFailedException|InterruptedException|ExecutionException ex) {
512 log.debug("Update DataStore failed");
513 throw new IllegalStateException(ex);
518 private void deletePreloadList(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path)
519 throws TransactionCommitFailedException, InterruptedException, ExecutionException {
520 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
521 tx.delete(storeType, path);
523 log.debug("DataStore delete succeeded");
527 public ListenableFuture<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
528 ServiceTopologyOperationInput input) {
530 final String svcOperation = "service-topology-operation";
531 ServiceData serviceData;
532 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
533 Properties parms = new Properties();
535 log.info(CALLED_STR, svcOperation);
536 // create a new response object
537 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
539 if (hasInvalidServiceId(input)) {
540 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
541 responseBuilder.setResponseCode("404");
542 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
543 responseBuilder.setAckFinalIndicator("Y");
545 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
546 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
548 return Futures.immediateFuture(rpcResult);
551 // Grab the service instance ID from the input buffer
552 String siid = input.getServiceInformation().getServiceInstanceId();
554 trySetSvcRequestId(input, responseBuilder);
556 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
557 getServiceData(siid, serviceDataBuilder);
559 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
560 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
562 // Set the serviceStatus based on input
563 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
564 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
567 * // setup a service-data object builder // ACTION service-topology-operation
568 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
569 * topology-response-common; // uses service-response-information;
572 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
573 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
574 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
576 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
577 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
579 // Call SLI sync method
580 ResponseObject responseObject = new ResponseObject("200", "");
581 String ackFinal = "Y";
582 String serviceObjectPath = null;
583 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
585 if (respProps != null) {
586 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
587 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
588 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
589 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
592 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
593 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
594 serviceStatusBuilder.setRpcName(svcOperation);
596 if (failed(responseObject)) {
597 responseBuilder.setResponseCode(responseObject.getStatusCode());
598 responseBuilder.setResponseMessage(responseObject.getMessage());
599 responseBuilder.setAckFinalIndicator(ackFinal);
601 ServiceBuilder serviceBuilder = new ServiceBuilder();
602 serviceBuilder.setServiceInstanceId(siid);
603 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
605 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
606 } catch (Exception e) {
607 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
609 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
611 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
612 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
614 return Futures.immediateFuture(rpcResult);
617 // Got success from SLI
619 serviceData = serviceDataBuilder.build();
620 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
623 ServiceBuilder serviceBuilder = new ServiceBuilder();
624 serviceBuilder.setServiceData(serviceData);
625 serviceBuilder.setServiceInstanceId(siid);
626 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
627 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
629 tryDeleteService(input, serviceBuilder);
631 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
632 serviceResponseInformationBuilder.setInstanceId(siid);
633 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
634 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
636 } catch (Exception e) {
637 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
638 responseBuilder.setResponseCode("500");
639 responseBuilder.setResponseMessage(e.getMessage());
640 responseBuilder.setAckFinalIndicator("Y");
641 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
643 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
644 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
646 return Futures.immediateFuture(rpcResult);
650 responseBuilder.setResponseCode(responseObject.getStatusCode());
651 responseBuilder.setAckFinalIndicator(ackFinal);
652 trySetResponseMessage(responseBuilder, responseObject);
653 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
654 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
656 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
657 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
659 return Futures.immediateFuture(rpcResult);
662 private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder,
663 ResponseObject responseObject) {
664 if (responseObject.getMessage() != null) {
665 responseBuilder.setResponseMessage(responseObject.getMessage());
669 private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
670 return input == null || input.getServiceInformation() == null
671 || input.getServiceInformation().getServiceInstanceId() == null
672 || input.getServiceInformation().getServiceInstanceId().length() == 0;
675 private void trySetSvcRequestId(ServiceTopologyOperationInput input,
676 ServiceTopologyOperationOutputBuilder responseBuilder) {
677 if (input.getSdncRequestHeader() != null) {
678 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
682 private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
683 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
684 // Only update operational tree on delete
685 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
686 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
687 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
691 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
692 ResponseObject responseObject) {
694 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
696 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
697 } catch (Exception e) {
698 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
699 responseObject.setMessage(e.getMessage());
700 responseObject.setStatusCode("500");
703 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
704 responseObject.setStatusCode("503");
706 } catch (Exception e) {
707 responseObject.setMessage(e.getMessage());
708 responseObject.setStatusCode("500");
709 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
715 private boolean failed(ResponseObject error) {
716 return !error.getStatusCode().isEmpty()
717 && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
720 private boolean isValidRequest(ServiceTopologyOperationInput input) {
721 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
726 public ListenableFuture<RpcResult<PnfTopologyOperationOutput>> pnfTopologyOperation(
727 PnfTopologyOperationInput input) {
729 final String svcOperation = "pnf-topology-operation";
730 ServiceData serviceData;
731 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
732 Properties properties = new Properties();
734 log.info(CALLED_STR, svcOperation);
735 // create a new response object
736 PnfTopologyOperationOutputBuilder responseBuilder = new PnfTopologyOperationOutputBuilder();
738 if (hasInvalidServiceId(input)) {
739 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
740 responseBuilder.setResponseCode("404");
741 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
742 responseBuilder.setAckFinalIndicator("Y");
743 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
744 .withResult(responseBuilder.build()).build();
746 return Futures.immediateFuture(rpcResult);
749 // Grab the service instance ID from the input buffer
750 String siid = input.getServiceInformation().getServiceInstanceId();
752 trySetSvcRequestId(input, responseBuilder);
754 /* Comment out mandatory check for pnf id for scenario wherein for assign/create request pnf-id is generated by
756 if (hasInvalidPnfId(input)) {
757 log.debug("exiting {} because of null or empty pnf-id", svcOperation);
758 responseBuilder.setResponseCode("404");
759 responseBuilder.setResponseMessage("invalid input, null or empty pnf-id");
760 responseBuilder.setAckFinalIndicator("Y");
762 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
763 .withResult(responseBuilder.build()).build();
765 return Futures.immediateFuture(rpcResult);
769 String pnfId = input.getPnfDetails().getPnfId();
770 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
771 getServiceData(siid, serviceDataBuilder);
773 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
774 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
776 // Set the serviceStatus based on input
777 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
778 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
781 // setup a service-data object builder
782 // ACTION pnf-topology-operation
784 // USES sdnc-request-header;
785 // USES request-information;
786 // USES service-information;
789 // USES pnf-topology-response-body;
791 // USES service-information
795 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
796 PnfTopologyOperationInputBuilder inputBuilder = new PnfTopologyOperationInputBuilder(input);
797 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
799 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
800 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
802 // Call SLI sync method
804 ResponseObject responseObject = new ResponseObject("200", "");
805 String ackFinal = "Y";
806 String serviceObjectPath = null;
807 String pnfObjectPath = null;
808 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
810 if (respProps != null) {
811 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
812 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
813 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
815 pnfId = respProps.getProperty("pnfId");
817 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
818 pnfObjectPath = respProps.getProperty(PNF_OBJECT_PATH_PARAM);
821 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
822 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
823 serviceStatusBuilder.setRpcName(svcOperation);
825 if (failed(responseObject)) {
826 responseBuilder.setResponseCode(responseObject.getStatusCode());
827 responseBuilder.setResponseMessage(responseObject.getMessage());
828 responseBuilder.setAckFinalIndicator(ackFinal);
830 ServiceBuilder serviceBuilder = new ServiceBuilder();
831 serviceBuilder.setServiceInstanceId(siid);
832 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
834 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
835 trySaveService(input, serviceBuilder);
836 } catch (Exception e) {
837 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
839 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
841 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
842 .withResult(responseBuilder.build()).build();
845 return Futures.immediateFuture(rpcResult);
848 // Got success from SLI
850 serviceData = serviceDataBuilder.build();
851 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
854 ServiceBuilder serviceBuilder = new ServiceBuilder();
855 serviceBuilder.setServiceData(serviceData);
856 serviceBuilder.setServiceInstanceId(siid);
857 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
858 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
860 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
861 // Only update operational tree on Assign
862 log.info(UPDATING_TREE_INFO_MESSAGE);
863 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
866 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
867 serviceResponseInformationBuilder.setInstanceId(siid);
868 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
869 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
871 PnfResponseInformationBuilder pnfResponseInformationBuilder = new PnfResponseInformationBuilder();
872 pnfResponseInformationBuilder.setInstanceId(pnfId);
873 pnfResponseInformationBuilder.setObjectPath(pnfObjectPath);
874 responseBuilder.setPnfResponseInformation(pnfResponseInformationBuilder.build());
876 } catch (Exception e) {
877 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
878 responseBuilder.setResponseCode("500");
879 responseBuilder.setResponseMessage(e.getMessage());
880 responseBuilder.setAckFinalIndicator("Y");
881 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
883 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
884 .withResult(responseBuilder.build()).build();
886 return Futures.immediateFuture(rpcResult);
890 responseBuilder.setResponseCode(responseObject.getStatusCode());
891 responseBuilder.setAckFinalIndicator(ackFinal);
892 trySetResponseMessage(responseBuilder, responseObject);
893 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
894 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
896 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
897 .withResult(responseBuilder.build()).build();
900 return Futures.immediateFuture(rpcResult);
903 private void trySetResponseMessage(PnfTopologyOperationOutputBuilder responseBuilder,
904 ResponseObject responseObject) {
905 if (responseObject.getMessage() != null) {
906 responseBuilder.setResponseMessage(responseObject.getMessage());
910 private void trySaveService(PnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
911 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
912 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
914 // Only update operational tree on activate or delete
915 log.info(UPDATING_TREE_INFO_MESSAGE);
916 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
920 private boolean hasInvalidPnfId(PnfTopologyOperationInput input) {
921 return input.getPnfDetails() == null || input.getPnfDetails().getPnfId() == null
922 || input.getPnfDetails().getPnfId().length() == 0;
925 private boolean hasInvalidServiceId(PnfTopologyOperationInput input) {
926 return input == null || input.getServiceInformation() == null
927 || input.getServiceInformation().getServiceInstanceId() == null
928 || input.getServiceInformation().getServiceInstanceId().length() == 0;
931 private void trySetSvcRequestId(PnfTopologyOperationInput input,
932 PnfTopologyOperationOutputBuilder responseBuilder) {
933 if (input.getSdncRequestHeader() != null) {
934 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
938 private boolean isValidRequest(PnfTopologyOperationInput input) {
939 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
944 public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
945 VnfTopologyOperationInput input) {
947 final String svcOperation = "vnf-topology-operation";
948 ServiceData serviceData;
949 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
950 Properties properties = new Properties();
952 log.info(CALLED_STR, svcOperation);
953 // create a new response object
954 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
956 if (hasInvalidServiceId(input)) {
957 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
958 responseBuilder.setResponseCode("404");
959 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
960 responseBuilder.setAckFinalIndicator("Y");
961 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
962 .withResult(responseBuilder.build()).build();
964 return Futures.immediateFuture(rpcResult);
967 // Grab the service instance ID from the input buffer
968 String siid = input.getServiceInformation().getServiceInstanceId();
970 trySetSvcRequestId(input, responseBuilder);
972 /* Comment out mandatory check for vnf id for scenario wherein for assign/create request vnf-id is generated by
974 if (hasInvalidVnfId(input)) {
975 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
976 responseBuilder.setResponseCode("404");
977 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
978 responseBuilder.setAckFinalIndicator("Y");
980 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
981 .withResult(responseBuilder.build()).build();
983 return Futures.immediateFuture(rpcResult);
987 String vnfId = input.getVnfInformation().getVnfId();
988 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
989 getServiceData(siid, serviceDataBuilder);
991 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
992 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
994 // Set the serviceStatus based on input
995 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
996 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
999 // setup a service-data object builder
1000 // ACTION vnf-topology-operation
1002 // USES sdnc-request-header;
1003 // USES request-information;
1004 // USES service-information;
1005 // USES vnf-request-information
1007 // USES vnf-topology-response-body;
1008 // USES vnf-information
1009 // USES service-information
1011 // container service-data
1012 // uses vnf-configuration-information;
1013 // uses oper-status;
1015 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1016 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1017 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1019 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1020 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
1022 // Call SLI sync method
1024 ResponseObject responseObject = new ResponseObject("200", "");
1025 String ackFinal = "Y";
1026 String serviceObjectPath = null;
1027 String vnfObjectPath = null;
1028 String skipMdsalUpdate = null;
1029 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1031 if (respProps != null) {
1032 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1033 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1034 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1035 if (vnfId == null) {
1036 vnfId = respProps.getProperty("vnfId");
1038 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1039 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1040 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1041 if (skipMdsalUpdate == null) {
1042 skipMdsalUpdate = "N";
1046 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1047 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1048 serviceStatusBuilder.setRpcName(svcOperation);
1050 if (failed(responseObject)) {
1051 responseBuilder.setResponseCode(responseObject.getStatusCode());
1052 responseBuilder.setResponseMessage(responseObject.getMessage());
1053 responseBuilder.setAckFinalIndicator(ackFinal);
1055 ServiceBuilder serviceBuilder = new ServiceBuilder();
1056 serviceBuilder.setServiceInstanceId(siid);
1057 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1059 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1060 trySaveService(input, serviceBuilder);
1061 } catch (Exception e) {
1062 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1064 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1066 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1067 .withResult(responseBuilder.build()).build();
1070 return Futures.immediateFuture(rpcResult);
1073 // Got success from SLI
1075 if (skipMdsalUpdate.equals("N")) {
1076 serviceData = serviceDataBuilder.build();
1077 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1080 ServiceBuilder serviceBuilder = new ServiceBuilder();
1081 serviceBuilder.setServiceData(serviceData);
1082 serviceBuilder.setServiceInstanceId(siid);
1083 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1084 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1086 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1087 // Only update operational tree on Assign
1088 log.info(UPDATING_TREE_INFO_MESSAGE);
1089 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1092 // Even if we are skipping the MD-SAL update, update the service status object
1093 ServiceBuilder serviceBuilder = new ServiceBuilder();
1094 serviceBuilder.setServiceInstanceId(siid);
1095 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1096 Service service = serviceBuilder.build();
1097 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1098 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1101 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1102 serviceResponseInformationBuilder.setInstanceId(siid);
1103 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1104 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1106 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1107 vnfResponseInformationBuilder.setInstanceId(vnfId);
1108 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1109 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1111 } catch (Exception e) {
1112 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1113 responseBuilder.setResponseCode("500");
1114 responseBuilder.setResponseMessage(e.getMessage());
1115 responseBuilder.setAckFinalIndicator("Y");
1116 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1118 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1119 .withResult(responseBuilder.build()).build();
1121 return Futures.immediateFuture(rpcResult);
1125 responseBuilder.setResponseCode(responseObject.getStatusCode());
1126 responseBuilder.setAckFinalIndicator(ackFinal);
1127 trySetResponseMessage(responseBuilder, responseObject);
1128 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1129 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1131 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1132 .withResult(responseBuilder.build()).build();
1134 if (ackFinal.equals("N")) {
1135 // Spawn background thread to invoke the Async DG
1136 Runnable backgroundThread = new Runnable() {
1138 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
1139 processAsyncVnfTopologyOperation(input);
1142 new Thread(backgroundThread).start();
1146 return Futures.immediateFuture(rpcResult);
1149 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
1150 ResponseObject responseObject) {
1151 if (responseObject.getMessage() != null) {
1152 responseBuilder.setResponseMessage(responseObject.getMessage());
1156 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1157 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
1158 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1160 // Only update operational tree on activate or delete
1161 log.info(UPDATING_TREE_INFO_MESSAGE);
1162 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1166 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
1167 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1168 || input.getVnfInformation().getVnfId().length() == 0;
1171 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
1172 return input == null || input.getServiceInformation() == null
1173 || input.getServiceInformation().getServiceInstanceId() == null
1174 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1177 private void trySetSvcRequestId(VnfTopologyOperationInput input,
1178 VnfTopologyOperationOutputBuilder responseBuilder) {
1179 if (input.getSdncRequestHeader() != null) {
1180 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1184 private boolean isValidRequest(VnfTopologyOperationInput input) {
1185 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1188 public void processAsyncVnfTopologyOperation(VnfTopologyOperationInput input) {
1189 log.info(BACKGROUND_THREAD_INFO, input.getVnfInformation().getVnfId());
1191 final String svcOperation = "vnf-topology-operation-async";
1192 ServiceData serviceData = null;
1193 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1194 Properties parms = new Properties();
1196 log.info(CALLED_STR, svcOperation);
1198 // create a new response object (for logging purposes only)
1199 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1201 // Grab the service instance ID from the input buffer
1202 String siid = input.getServiceInformation().getServiceInstanceId();
1203 String vnfId = input.getVnfInformation().getVnfId();
1205 trySetSvcRequestId(input, responseBuilder);
1207 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1208 getServiceData(siid, serviceDataBuilder);
1210 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1211 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1213 // Set the serviceStatus based on input
1214 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1215 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1218 // setup a service-data object builder
1219 // ACTION vnf-topology-operation
1221 // USES sdnc-request-header;
1222 // USES request-information;
1223 // USES service-information;
1224 // USES vnf-request-information
1226 // USES vnf-topology-response-body;
1227 // USES vnf-information
1228 // USES service-information
1230 // container service-data
1231 // uses vnf-configuration-information;
1232 // uses oper-status;
1234 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1235 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1236 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1238 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1239 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1241 // Call SLI sync method
1243 ResponseObject responseObject = new ResponseObject("200", "");
1244 String ackFinal = "Y";
1245 String serviceObjectPath = null;
1246 String vnfObjectPath = null;
1247 String skipMdsalUpdate = null;
1248 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1250 if (respProps != null) {
1251 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1252 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1253 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1254 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1255 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1256 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1257 if (skipMdsalUpdate == null) {
1258 skipMdsalUpdate = "N";
1262 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1263 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1264 serviceStatusBuilder.setRpcName(svcOperation);
1266 if (failed(responseObject)) {
1267 responseBuilder.setResponseCode(responseObject.getStatusCode());
1268 responseBuilder.setResponseMessage(responseObject.getMessage());
1269 responseBuilder.setAckFinalIndicator(ackFinal);
1271 ServiceBuilder serviceBuilder = new ServiceBuilder();
1272 serviceBuilder.setServiceInstanceId(siid);
1273 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1275 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1276 } catch (Exception e) {
1277 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1279 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1283 // Got success from SLI
1285 if (skipMdsalUpdate.equals("N")) {
1286 serviceData = serviceDataBuilder.build();
1287 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1290 ServiceBuilder serviceBuilder = new ServiceBuilder();
1291 serviceBuilder.setServiceData(serviceData);
1292 serviceBuilder.setServiceInstanceId(siid);
1293 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1294 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1296 trySaveService(input, serviceBuilder);
1298 // Even if we are skipping the MD-SAL update, update the service status object
1299 ServiceBuilder serviceBuilder = new ServiceBuilder();
1300 serviceBuilder.setServiceInstanceId(siid);
1301 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1302 Service service = serviceBuilder.build();
1303 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1304 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1307 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1308 serviceResponseInformationBuilder.setInstanceId(siid);
1309 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1310 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1312 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1313 vnfResponseInformationBuilder.setInstanceId(vnfId);
1314 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1315 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1317 } catch (Exception e) {
1318 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1319 responseBuilder.setResponseCode("500");
1320 responseBuilder.setResponseMessage(e.getMessage());
1321 responseBuilder.setAckFinalIndicator("Y");
1322 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1328 responseBuilder.setResponseCode(responseObject.getStatusCode());
1329 responseBuilder.setAckFinalIndicator(ackFinal);
1330 trySetResponseMessage(responseBuilder, responseObject);
1331 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1332 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1337 public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1338 VfModuleTopologyOperationInput input) {
1340 final String svcOperation = "vf-module-topology-operation";
1341 ServiceData serviceData;
1342 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1343 Properties parms = new Properties();
1345 log.info(CALLED_STR, svcOperation);
1346 // create a new response object
1347 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1349 if (hasInvalidServiceId(input)) {
1350 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1351 responseBuilder.setResponseCode("403");
1352 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1353 responseBuilder.setAckFinalIndicator("Y");
1355 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1356 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1359 return Futures.immediateFuture(rpcResult);
1362 if (hasInvalidVnfId(input)) {
1363 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1364 responseBuilder.setResponseCode("403");
1365 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1366 responseBuilder.setAckFinalIndicator("Y");
1367 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1368 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1369 return Futures.immediateFuture(rpcResult);
1372 /*if (hasInvalidVfModuleId(input)) {
1373 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1374 responseBuilder.setResponseCode("403");
1375 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1376 responseBuilder.setAckFinalIndicator("Y");
1378 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1379 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1381 return Futures.immediateFuture(rpcResult);
1384 // Grab the service instance ID from the input buffer
1385 String siid = input.getServiceInformation().getServiceInstanceId();
1386 String vnfId = input.getVnfInformation().getVnfId();
1387 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1389 trySetSvcRequestId(input, responseBuilder);
1391 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1392 getServiceData(siid, serviceDataBuilder);
1394 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1395 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1397 // Set the serviceStatus based on input
1398 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1399 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1402 // setup a service-data object builder
1403 // ACTION vnf-topology-operation
1405 // USES sdnc-request-header;
1406 // USES request-information;
1407 // USES service-information;
1408 // USES vnf-request-information
1410 // USES vnf-topology-response-body;
1411 // USES vnf-information
1412 // USES service-information
1414 // container service-data
1415 // uses vnf-configuration-information;
1416 // uses oper-status;
1418 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1419 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1420 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1422 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1423 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1425 // Call SLI sync method
1427 ResponseObject responseObject = new ResponseObject("200", "");
1428 String ackFinal = "Y";
1429 String serviceObjectPath = null;
1430 String vnfObjectPath = null;
1431 String vfModuleObjectPath = null;
1432 String skipMdsalUpdate = null;
1433 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1435 if (respProps != null) {
1436 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1437 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1438 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1439 if (vfModuleId == null) {
1440 vfModuleId = respProps.getProperty(VF_MODULE_ID_PARAM);
1441 if (vfModuleId == null) {
1442 log.debug("exiting {} because vf-module-id not found in response", svcOperation);
1443 responseBuilder.setResponseCode("403");
1444 responseBuilder.setResponseMessage("failed to generate vf-module-id");
1445 responseBuilder.setAckFinalIndicator("Y");
1447 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1448 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1450 return Futures.immediateFuture(rpcResult);
1453 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1454 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1455 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1456 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1457 if (skipMdsalUpdate == null) {
1458 skipMdsalUpdate = "N";
1462 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1463 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1464 serviceStatusBuilder.setRpcName(svcOperation);
1466 if (failed(responseObject)) {
1467 responseBuilder.setResponseCode(responseObject.getStatusCode());
1468 responseBuilder.setResponseMessage(responseObject.getMessage());
1469 responseBuilder.setAckFinalIndicator(ackFinal);
1471 ServiceBuilder serviceBuilder = new ServiceBuilder();
1472 serviceBuilder.setServiceInstanceId(siid);
1473 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1475 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1476 } catch (Exception e) {
1477 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1479 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1481 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1482 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1485 return Futures.immediateFuture(rpcResult);
1488 // Got success from SLI
1490 if (skipMdsalUpdate.equals("N")) {
1491 serviceData = serviceDataBuilder.build();
1492 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1495 ServiceBuilder serviceBuilder = new ServiceBuilder();
1496 serviceBuilder.setServiceData(serviceData);
1497 serviceBuilder.setServiceInstanceId(siid);
1498 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1499 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1501 trySaveService(input, serviceBuilder);
1503 // Even if we are skipping the MD-SAL update, update the service status object
1504 ServiceBuilder serviceBuilder = new ServiceBuilder();
1505 serviceBuilder.setServiceInstanceId(siid);
1506 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1507 Service service = serviceBuilder.build();
1508 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1509 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1512 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1513 serviceResponseInformationBuilder.setInstanceId(siid);
1514 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1515 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1517 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1518 vnfResponseInformationBuilder.setInstanceId(vnfId);
1519 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1520 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1522 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1523 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1524 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1525 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1527 } catch (Exception e) {
1528 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1529 responseBuilder.setResponseCode("500");
1530 responseBuilder.setResponseMessage(e.getMessage());
1531 responseBuilder.setAckFinalIndicator("Y");
1532 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1534 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1535 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1537 return Futures.immediateFuture(rpcResult);
1541 responseBuilder.setResponseCode(responseObject.getStatusCode());
1542 responseBuilder.setAckFinalIndicator(ackFinal);
1543 trySetResponseMessage(responseBuilder, responseObject);
1544 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1545 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1547 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1548 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1550 if (ackFinal.equals("N")) {
1551 // Spawn background thread to invoke the Async DG
1552 Runnable backgroundThread = new Runnable() {
1554 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
1555 processAsyncVfModuleTopologyOperation(input);
1558 new Thread(backgroundThread).start();
1562 return Futures.immediateFuture(rpcResult);
1565 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1566 ResponseObject responseObject) {
1567 if (responseObject.getMessage() != null) {
1568 responseBuilder.setResponseMessage(responseObject.getMessage());
1572 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1573 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1574 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1575 // Only update operational tree on activate or delete
1577 log.info(UPDATING_TREE_INFO_MESSAGE);
1578 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1582 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1583 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1584 if (input.getSdncRequestHeader() != null) {
1585 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1589 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1590 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1591 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1594 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1595 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1596 || input.getVnfInformation().getVnfId().length() == 0;
1599 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1600 return input == null || input.getServiceInformation() == null
1601 || input.getServiceInformation().getServiceInstanceId() == null
1602 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1605 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1606 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1609 public void processAsyncVfModuleTopologyOperation(VfModuleTopologyOperationInput input) {
1610 log.info(BACKGROUND_THREAD_INFO, input.getVfModuleInformation().getVfModuleId());
1612 final String svcOperation = "vf-module-topology-operation-async";
1613 ServiceData serviceData = null;
1614 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1615 Properties parms = new Properties();
1617 log.info(CALLED_STR, svcOperation);
1619 // create a new response object (for logging purposes only)
1620 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1622 // Grab the service instance ID from the input buffer
1623 String siid = input.getServiceInformation().getServiceInstanceId();
1624 String vnfId = input.getVnfInformation().getVnfId();
1625 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1627 trySetSvcRequestId(input, responseBuilder);
1629 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1630 getServiceData(siid, serviceDataBuilder);
1632 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1633 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1635 // Set the serviceStatus based on input
1636 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1637 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1640 // setup a service-data object builder
1641 // ACTION vnf-topology-operation
1643 // USES sdnc-request-header;
1644 // USES request-information;
1645 // USES service-information;
1646 // USES vnf-request-information
1648 // USES vnf-topology-response-body;
1649 // USES vnf-information
1650 // USES service-information
1652 // container service-data
1653 // uses vnf-configuration-information;
1654 // uses oper-status;
1656 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1657 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1658 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1660 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1661 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1663 // Call SLI sync method
1665 ResponseObject responseObject = new ResponseObject("200", "");
1666 String ackFinal = "Y";
1667 String serviceObjectPath = null;
1668 String vnfObjectPath = null;
1669 String vfModuleObjectPath = null;
1670 String skipMdsalUpdate = null;
1671 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1673 if (respProps != null) {
1674 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1675 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1676 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1677 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1678 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1679 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1680 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1681 if (skipMdsalUpdate == null) {
1682 skipMdsalUpdate = "N";
1686 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1687 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1688 serviceStatusBuilder.setRpcName(svcOperation);
1690 if (failed(responseObject)) {
1691 responseBuilder.setResponseCode(responseObject.getStatusCode());
1692 responseBuilder.setResponseMessage(responseObject.getMessage());
1693 responseBuilder.setAckFinalIndicator(ackFinal);
1695 ServiceBuilder serviceBuilder = new ServiceBuilder();
1696 serviceBuilder.setServiceInstanceId(siid);
1697 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1699 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1700 } catch (Exception e) {
1701 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1703 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1707 // Got success from SLI
1709 if (skipMdsalUpdate.equals("N")) {
1710 serviceData = serviceDataBuilder.build();
1711 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1714 ServiceBuilder serviceBuilder = new ServiceBuilder();
1715 serviceBuilder.setServiceData(serviceData);
1716 serviceBuilder.setServiceInstanceId(siid);
1717 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1718 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1720 trySaveService(input, serviceBuilder);
1722 // Even if we are skipping the MD-SAL update, update the service status object
1723 ServiceBuilder serviceBuilder = new ServiceBuilder();
1724 serviceBuilder.setServiceInstanceId(siid);
1725 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1726 Service service = serviceBuilder.build();
1727 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1728 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1731 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1732 serviceResponseInformationBuilder.setInstanceId(siid);
1733 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1734 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1736 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1737 vnfResponseInformationBuilder.setInstanceId(vnfId);
1738 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1739 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1741 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1742 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1743 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1744 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1746 } catch (Exception e) {
1747 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1748 responseBuilder.setResponseCode("500");
1749 responseBuilder.setResponseMessage(e.getMessage());
1750 responseBuilder.setAckFinalIndicator("Y");
1751 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1757 responseBuilder.setResponseCode(responseObject.getStatusCode());
1758 responseBuilder.setAckFinalIndicator(ackFinal);
1759 trySetResponseMessage(responseBuilder, responseObject);
1760 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1761 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1766 public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1767 NetworkTopologyOperationInput input) {
1769 final String svcOperation = "network-topology-operation";
1770 ServiceData serviceData;
1771 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1772 Properties parms = new Properties();
1774 log.info(CALLED_STR, svcOperation);
1775 // create a new response object
1776 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1778 if (hasInvalidServiceId(input)) {
1779 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1780 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1783 String siid = input.getServiceInformation().getServiceInstanceId();
1785 // Get the service-instance service data from MD-SAL
1786 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1787 getServiceData(siid, serviceDataBuilder);
1789 this.trySetSvcRequestId(input, responseBuilder);
1791 ServiceData sd = serviceDataBuilder.build();
1792 if (isInvalidServiceData(sd)) {
1793 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1794 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1797 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1798 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1799 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1801 // Call SLI sync method
1803 ResponseObject responseObject = new ResponseObject("200", "");
1804 String ackFinal = "Y";
1805 String networkId = ERROR_NETWORK_ID;
1806 String serviceObjectPath = null;
1807 String networkObjectPath = null;
1808 String skipMdsalUpdate = null;
1809 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1811 if (respProps != null) {
1812 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1813 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1814 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1815 networkId = respProps.getProperty("networkId");
1816 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1817 networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1818 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1819 if (skipMdsalUpdate == null) {
1820 skipMdsalUpdate = "N";
1824 if (failed(responseObject)) {
1825 responseBuilder.setResponseCode(responseObject.getStatusCode());
1826 responseBuilder.setResponseMessage(responseObject.getMessage());
1827 responseBuilder.setAckFinalIndicator(ackFinal);
1829 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1831 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1832 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1834 return Futures.immediateFuture(rpcResult);
1837 // Got success from SLI
1839 if (skipMdsalUpdate.equals("N")) {
1840 serviceData = serviceDataBuilder.build();
1841 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1844 ServiceBuilder serviceBuilder = new ServiceBuilder();
1845 serviceBuilder.setServiceData(serviceData);
1846 serviceBuilder.setServiceInstanceId(siid);
1847 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1848 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1850 trySaveService(input, serviceBuilder);
1852 // Even if we are skipping the MD-SAL update, update the service status object
1853 ServiceBuilder serviceBuilder = new ServiceBuilder();
1854 serviceBuilder.setServiceInstanceId(siid);
1855 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1856 Service service = serviceBuilder.build();
1857 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1858 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1861 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1862 networkResponseInformationBuilder.setInstanceId(networkId);
1863 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1864 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1866 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1867 serviceResponseInformationBuilder.setInstanceId(siid);
1868 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1869 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1870 } catch (IllegalStateException e) {
1871 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1872 responseBuilder.setResponseCode("500");
1873 responseBuilder.setResponseMessage(e.getMessage());
1874 responseBuilder.setAckFinalIndicator("Y");
1875 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1877 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1878 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1880 return Futures.immediateFuture(rpcResult);
1884 responseBuilder.setResponseCode(responseObject.getStatusCode());
1885 responseBuilder.setAckFinalIndicator(ackFinal);
1886 trySetResponseMessage(responseBuilder, responseObject);
1887 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1888 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1890 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1891 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1893 return Futures.immediateFuture(rpcResult);
1896 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1897 ResponseObject responseObject) {
1898 if (responseObject.getMessage() != null) {
1899 responseBuilder.setResponseMessage(responseObject.getMessage());
1903 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1904 NetworkTopologyOperationOutputBuilder responseBuilder) {
1905 if (input.getSdncRequestHeader() != null) {
1906 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1910 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1911 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1912 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1913 // Only update operational tree on Activate
1914 log.info(UPDATING_TREE_INFO_MESSAGE);
1915 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1919 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1920 return input == null || input.getServiceInformation() == null
1921 || input.getServiceInformation().getServiceInstanceId() == null
1922 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1925 private ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1926 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1928 responseBuilder.setResponseCode("404");
1929 responseBuilder.setResponseMessage(responseMessage);
1930 responseBuilder.setAckFinalIndicator("Y");
1932 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1933 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1935 return Futures.immediateFuture(rpcResult);
1938 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1939 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1943 public ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1944 ContrailRouteTopologyOperationInput input) {
1946 final String svcOperation = "contrail-route-topology-operation";
1947 ServiceData serviceData;
1948 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1949 Properties properties = new Properties();
1951 log.info(CALLED_STR, svcOperation);
1952 // create a new response object
1953 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1955 if (hasInvalidServiceId(input)) {
1956 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1957 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1960 String siid = input.getServiceInformation().getServiceInstanceId();
1962 // Get the service-instance service data from MD-SAL
1963 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1964 getServiceData(siid, serviceDataBuilder);
1966 trySetSvcRequestId(input, responseBuilder);
1968 ServiceData sd = serviceDataBuilder.build();
1969 if (isInvalidServiceData(sd)) {
1970 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1971 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1974 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1975 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1976 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1978 // Call SLI sync method
1980 ResponseObject responseObject = new ResponseObject("200", "");
1981 String ackFinal = "Y";
1982 String allottedResourceId = ERROR_NETWORK_ID;
1983 String serviceObjectPath = null;
1984 String contrailRouteObjectPath = null;
1985 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1987 if (respProps != null) {
1988 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1989 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1990 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1991 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1992 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1993 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1996 if (failed(responseObject)) {
1997 responseBuilder.setResponseCode(responseObject.getStatusCode());
1998 responseBuilder.setResponseMessage(responseObject.getMessage());
1999 responseBuilder.setAckFinalIndicator(ackFinal);
2000 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2002 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2003 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2005 return Futures.immediateFuture(rpcResult);
2008 // Got success from SLI
2010 serviceData = serviceDataBuilder.build();
2011 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2014 ServiceBuilder serviceBuilder = new ServiceBuilder();
2015 serviceBuilder.setServiceData(serviceData);
2016 serviceBuilder.setServiceInstanceId(siid);
2017 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2018 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2020 trySaveService(input, serviceBuilder);
2022 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
2023 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
2024 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
2025 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
2027 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2028 serviceResponseInformationBuilder.setInstanceId(siid);
2029 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2030 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2032 } catch (IllegalStateException e) {
2033 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2034 responseBuilder.setResponseCode("500");
2035 responseBuilder.setResponseMessage(e.getMessage());
2036 responseBuilder.setAckFinalIndicator("Y");
2037 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2039 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2040 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2042 return Futures.immediateFuture(rpcResult);
2046 responseBuilder.setResponseCode(responseObject.getStatusCode());
2047 responseBuilder.setAckFinalIndicator(ackFinal);
2048 trySetResponseMessage(responseBuilder, responseObject);
2049 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2050 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2052 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2053 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2055 return Futures.immediateFuture(rpcResult);
2058 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
2059 ResponseObject responseObject) {
2060 if (responseObject.getMessage() != null) {
2061 responseBuilder.setResponseMessage(responseObject.getMessage());
2065 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2066 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
2067 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2068 // Only update operational tree on activate or delete
2069 log.info(UPDATING_TREE_INFO_MESSAGE);
2070 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2074 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
2075 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
2076 if (input.getSdncRequestHeader() != null) {
2077 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2081 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
2082 return input == null || input.getServiceInformation() == null
2083 || input.getServiceInformation().getServiceInstanceId() == null
2084 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2087 private ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
2088 ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2089 responseBuilder.setResponseCode("404");
2090 responseBuilder.setResponseMessage(responseMessage);
2091 responseBuilder.setAckFinalIndicator("Y");
2093 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2094 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2096 return Futures.immediateFuture(rpcResult);
2099 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
2100 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2104 public ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
2105 SecurityZoneTopologyOperationInput input) {
2107 final String svcOperation = "security-zone-topology-operation";
2108 ServiceData serviceData;
2109 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2110 Properties parms = new Properties();
2112 log.info(CALLED_STR, svcOperation);
2113 // create a new response object
2114 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
2116 if (this.hasInvalidServiceId(input)) {
2117 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2118 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
2121 String siid = input.getServiceInformation().getServiceInstanceId();
2123 // Get the service-instance service data from MD-SAL
2124 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2125 getServiceData(siid, serviceDataBuilder);
2126 trySetSvcRequestId(input, responseBuilder);
2128 ServiceData sd = serviceDataBuilder.build();
2129 if (isInvalidServiceData(sd)) {
2130 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2131 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2134 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2135 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
2136 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2138 // Call SLI sync method
2140 Properties respProps = null;
2142 ResponseObject responseObject = new ResponseObject("200", "");
2143 String ackFinal = "Y";
2144 String allottedResourceId = ERROR_NETWORK_ID;
2145 String serviceObjectPath = null;
2146 String securityZoneObjectPath = null;
2149 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2152 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
2153 } catch (Exception e) {
2154 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2155 responseObject.setMessage(e.getMessage());
2156 responseObject.setStatusCode("500");
2159 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2160 responseObject.setStatusCode("503");
2162 } catch (Exception e) {
2163 responseObject.setStatusCode("500");
2164 responseObject.setMessage(e.getMessage());
2165 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2168 if (respProps != null) {
2169 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2170 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2171 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2172 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2173 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2174 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
2177 if (failed(responseObject)) {
2178 responseBuilder.setResponseCode(responseObject.getStatusCode());
2179 responseBuilder.setResponseMessage(responseObject.getMessage());
2180 responseBuilder.setAckFinalIndicator(ackFinal);
2181 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2183 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2184 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2186 return Futures.immediateFuture(rpcResult);
2189 // Got success from SLI
2192 serviceData = serviceDataBuilder.build();
2193 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2196 ServiceBuilder serviceBuilder = new ServiceBuilder();
2197 serviceBuilder.setServiceData(serviceData);
2198 serviceBuilder.setServiceInstanceId(siid);
2199 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2200 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2202 trySaveService(input, serviceBuilder);
2204 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
2205 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
2206 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
2207 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
2209 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2210 serviceResponseInformationBuilder.setInstanceId(siid);
2211 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2212 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2214 } catch (IllegalStateException e) {
2215 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2216 responseBuilder.setResponseCode("500");
2217 responseBuilder.setResponseMessage(e.getMessage());
2218 responseBuilder.setAckFinalIndicator("Y");
2219 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2221 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2222 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2224 return Futures.immediateFuture(rpcResult);
2228 responseBuilder.setResponseCode(responseObject.getStatusCode());
2229 responseBuilder.setAckFinalIndicator(ackFinal);
2230 trySetResponseMessage(responseBuilder, responseObject);
2231 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2232 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2234 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2235 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2237 return Futures.immediateFuture(rpcResult);
2240 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
2241 ResponseObject responseObject) {
2242 if (responseObject.getMessage() != null) {
2243 responseBuilder.setResponseMessage(responseObject.getMessage());
2247 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2248 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
2249 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2250 // Only update operational tree on activate or delete
2251 log.info(UPDATING_TREE_INFO_MESSAGE);
2252 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2256 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
2257 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
2258 if (input.getSdncRequestHeader() != null) {
2259 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2263 private boolean isInvalidServiceData(ServiceData sd) {
2264 return sd == null || sd.getServiceLevelOperStatus() == null;
2267 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
2268 return input == null || input.getServiceInformation() == null
2269 || input.getServiceInformation().getServiceInstanceId() == null
2270 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2273 private ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
2274 SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2276 responseBuilder.setResponseCode("404");
2277 responseBuilder.setResponseMessage(responseMessage);
2278 responseBuilder.setAckFinalIndicator("Y");
2280 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2281 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2283 return Futures.immediateFuture(rpcResult);
2286 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
2287 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2291 private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
2292 return input == null || input.getServiceInformation() == null
2293 || input.getServiceInformation().getServiceInstanceId() == null
2294 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2297 private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
2298 ResponseObject error) {
2299 if (!error.getMessage().isEmpty()) {
2300 responseBuilder.setResponseMessage(error.getMessage());
2304 private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
2305 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
2306 if (input.getSdncRequestHeader() != null) {
2307 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2311 private ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
2312 buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2314 responseBuilder.setResponseCode("404");
2315 responseBuilder.setResponseMessage(responseMessage);
2316 responseBuilder.setAckFinalIndicator("Y");
2318 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2319 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2320 .withResult(responseBuilder.build())
2323 return Futures.immediateFuture(rpcResult);
2326 private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2327 if (isValidRequest(input) &&
2328 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
2329 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2330 // Only update operational tree on activate or delete
2331 log.info(UPDATING_TREE_INFO_MESSAGE);
2332 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2336 private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
2337 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2341 public ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(
2342 ConnectionAttachmentTopologyOperationInput input) {
2343 final String svcOperation = "connection-attachment-topology-operation";
2344 Properties parms = new Properties();
2345 log.info(CALLED_STR, svcOperation);
2347 // create a new response object
2348 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
2349 if (hasInvalidServiceId(input)) {
2350 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2351 responseBuilder.setResponseCode("404");
2352 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2353 responseBuilder.setAckFinalIndicator("Y");
2355 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2356 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2357 .withResult(responseBuilder.build())
2360 return Futures.immediateFuture(rpcResult);
2363 ServiceData serviceData;
2364 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2366 String siid = input.getServiceInformation().getServiceInstanceId();
2367 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2369 // Get the service-instance service data from MD-SAL
2370 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2371 getServiceData(siid, serviceDataBuilder);
2373 trySetSvcRequestId(input, responseBuilder);
2375 ServiceData sd = serviceDataBuilder.build();
2376 if (isInvalidServiceData(sd)) {
2377 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2378 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2381 ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(
2383 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2385 // Call SLI sync method
2386 // Get SvcLogicService reference
2387 ResponseObject responseObject = new ResponseObject("200", "");
2388 String ackFinal = "Y";
2389 String allottedResourceId = ERROR_NETWORK_ID;
2390 String serviceObjectPath = null;
2391 String connectionAttachmentObjectPath = null;
2393 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2395 if (respProps != null) {
2396 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2397 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2398 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2399 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2400 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2401 connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
2404 if (failed(responseObject)) {
2405 responseBuilder.setResponseCode(responseObject.getStatusCode());
2406 responseBuilder.setResponseMessage(responseObject.getMessage());
2407 responseBuilder.setAckFinalIndicator(ackFinal);
2409 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2411 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2412 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2413 .withResult(responseBuilder.build())
2416 return Futures.immediateFuture(rpcResult);
2419 // Got success from SLI
2422 serviceData = serviceDataBuilder.build();
2423 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2426 ServiceBuilder serviceBuilder = new ServiceBuilder();
2427 serviceBuilder.setServiceData(serviceData);
2428 serviceBuilder.setServiceInstanceId(siid);
2429 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2430 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2432 trySaveService(input, serviceBuilder);
2434 ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
2435 connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
2436 connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
2438 .setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
2440 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2441 serviceResponseInformationBuilder.setInstanceId(siid);
2442 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2443 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2445 } catch (IllegalStateException e) {
2446 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2447 responseBuilder.setResponseCode("500");
2448 responseBuilder.setResponseMessage(e.getMessage());
2449 responseBuilder.setAckFinalIndicator("Y");
2450 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2452 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2453 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2454 .withResult(responseBuilder.build())
2457 return Futures.immediateFuture(rpcResult);
2461 responseBuilder.setResponseCode(responseObject.getStatusCode());
2462 responseBuilder.setAckFinalIndicator(ackFinal);
2463 trySetResponseMessage(responseBuilder, responseObject);
2464 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2465 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2467 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2468 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2469 .withResult(responseBuilder.build())
2472 return Futures.immediateFuture(rpcResult);
2476 public ListenableFuture<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
2477 TunnelxconnTopologyOperationInput input) {
2479 final String svcOperation = "tunnelxconn-topology-operation";
2480 Properties parms = new Properties();
2481 log.info(CALLED_STR, svcOperation);
2483 // create a new response object
2484 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
2485 if (hasInvalidServiceId(input)) {
2486 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2487 responseBuilder.setResponseCode("404");
2488 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2489 responseBuilder.setAckFinalIndicator("Y");
2491 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2492 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2494 return Futures.immediateFuture(rpcResult);
2496 String siid = input.getServiceInformation().getServiceInstanceId();
2497 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2498 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
2499 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2501 // Call SLI sync method
2503 ResponseObject responseObject = new ResponseObject("200", "");
2504 String ackFinal = "Y";
2505 String allottedResourceId = ERROR_NETWORK_ID;
2506 String serviceObjectPath = null;
2507 String tunnelxconnObjectPath = null;
2508 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2510 if (respProps != null) {
2511 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2512 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2513 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2514 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2515 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2516 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
2519 if (failed(responseObject)) {
2520 responseBuilder.setResponseCode(responseObject.getStatusCode());
2521 responseBuilder.setResponseMessage(responseObject.getMessage());
2522 responseBuilder.setAckFinalIndicator(ackFinal);
2524 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2526 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2527 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2529 return Futures.immediateFuture(rpcResult);
2532 // Got success from SLI
2534 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
2535 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
2536 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
2537 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
2539 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2540 serviceResponseInformationBuilder.setInstanceId(siid);
2541 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2542 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2544 } catch (IllegalStateException e) {
2545 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2546 responseBuilder.setResponseCode("500");
2547 responseBuilder.setResponseMessage(e.getMessage());
2548 responseBuilder.setAckFinalIndicator("Y");
2549 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2551 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2552 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2554 return Futures.immediateFuture(rpcResult);
2558 responseBuilder.setResponseCode(responseObject.getStatusCode());
2559 responseBuilder.setAckFinalIndicator(ackFinal);
2560 trySetResponseMessage(responseBuilder, responseObject);
2561 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2562 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2564 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2565 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2567 return Futures.immediateFuture(rpcResult);
2570 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2571 ResponseObject responseObject) {
2572 if (responseObject.getMessage() != null) {
2573 responseBuilder.setResponseMessage(responseObject.getMessage());
2577 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2578 return input == null || input.getServiceInformation() == null
2579 || input.getServiceInformation().getServiceInstanceId() == null
2580 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2583 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2585 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2588 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2589 } catch (Exception e) {
2590 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2591 responseObject.setMessage(e.getMessage());
2592 responseObject.setStatusCode("500");
2595 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2596 responseObject.setStatusCode("503");
2598 } catch (Exception e) {
2599 responseObject.setMessage(e.getMessage());
2600 responseObject.setStatusCode("500");
2601 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2607 public ListenableFuture<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(
2608 BrgTopologyOperationInput input) {
2609 final String svcOperation = "brg-topology-operation";
2610 Properties parms = new Properties();
2612 log.info(CALLED_STR, svcOperation);
2613 // create a new response object
2614 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2616 if (this.hasInvalidServiceId(input)) {
2618 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2619 responseBuilder.setResponseCode("404");
2620 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2621 responseBuilder.setAckFinalIndicator("Y");
2623 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2624 .withResult(responseBuilder.build()).build();
2626 return Futures.immediateFuture(rpcResult);
2629 String siid = input.getServiceInformation().getServiceInstanceId();
2631 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2632 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2633 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2635 // Call SLI sync method
2637 ResponseObject responseObject = new ResponseObject("200", "");
2638 String ackFinal = "Y";
2639 String allottedResourceId = ERROR_NETWORK_ID;
2640 String serviceObjectPath = null;
2641 String brgObjectPath = null;
2642 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2644 if (respProps != null) {
2645 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2646 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2647 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2648 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2649 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2650 brgObjectPath = respProps.getProperty("brg-object-path");
2653 if (failed(responseObject)) {
2654 responseBuilder.setResponseCode(responseObject.getStatusCode());
2655 responseBuilder.setResponseMessage(responseObject.getMessage());
2656 responseBuilder.setAckFinalIndicator(ackFinal);
2658 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2659 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2660 .withResult(responseBuilder.build()).build();
2662 return Futures.immediateFuture(rpcResult);
2665 // Got success from SLI
2668 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2669 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2670 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2671 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2673 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2674 serviceResponseInformationBuilder.setInstanceId(siid);
2675 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2676 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2678 } catch (IllegalStateException e) {
2679 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2680 responseBuilder.setResponseCode("500");
2681 responseBuilder.setResponseMessage(e.getMessage());
2682 responseBuilder.setAckFinalIndicator("Y");
2683 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2685 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2686 .withResult(responseBuilder.build()).build();
2688 return Futures.immediateFuture(rpcResult);
2692 responseBuilder.setResponseCode(responseObject.getStatusCode());
2693 responseBuilder.setAckFinalIndicator(ackFinal);
2694 trySetResponseMessage(responseBuilder, responseObject);
2695 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2696 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2698 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2699 .withResult(responseBuilder.build()).build();
2701 return Futures.immediateFuture(rpcResult);
2704 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2705 ResponseObject responseObject) {
2706 if (responseObject.getMessage() != null) {
2707 responseBuilder.setResponseMessage(responseObject.getMessage());
2711 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2712 return input == null || input.getServiceInformation() == null
2713 || input.getServiceInformation().getServiceInstanceId() == null
2714 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2717 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2718 if (respProps != null) {
2719 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2720 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2721 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2727 public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2728 PreloadNetworkTopologyOperationInput input) {
2730 final String svcOperation = "preload-network-topology-operation";
2731 PreloadData preloadData;
2732 Properties properties = new Properties();
2734 log.info(CALLED_STR, svcOperation);
2735 // create a new response object
2736 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2738 if (hasInvalidPreloadNetwork(input)) {
2739 log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2740 responseBuilder.setResponseCode("403");
2741 responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2742 responseBuilder.setAckFinalIndicator("Y");
2744 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2745 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2747 return Futures.immediateFuture(rpcResult);
2750 // Grab the preload ID from the input buffer
2751 String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2753 String preloadType = "network";
2755 trySetSvcRequestId(input, responseBuilder);
2757 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2758 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2760 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2761 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2764 // setup a preload-data object builder
2765 // ACTION preload-network-topology-operation
2767 // uses sdnc-request-header;
2768 // uses request-information;
2769 // uses preload-network-topology-information;
2771 // uses preload-topology-response-body;
2773 // container preload-data
2774 // uses preload-network-topology-information;
2775 // uses preload-oper-status;
2777 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2778 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2780 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2781 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2782 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2784 // Call SLI sync method
2785 ResponseObject responseObject = new ResponseObject("200", "");
2786 String ackFinal = "Y";
2787 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2789 if (respProps != null) {
2790 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2791 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2792 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2795 if (failed(responseObject)) {
2796 responseBuilder.setResponseCode(responseObject.getStatusCode());
2797 responseBuilder.setResponseMessage(responseObject.getMessage());
2798 responseBuilder.setAckFinalIndicator(ackFinal);
2799 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2800 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2801 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2802 return Futures.immediateFuture(rpcResult);
2805 // Got success from SLI
2807 preloadData = preloadDataBuilder.build();
2808 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2810 // preload-list object
2811 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2812 preloadListBuilder.setPreloadId(preloadId);
2813 preloadListBuilder.setPreloadType(preloadType);
2814 preloadListBuilder.setPreloadData(preloadData);
2816 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2817 log.info(UPDATING_TREE_INFO_MESSAGE);
2818 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2820 tryDeletePreload(input, preloadListBuilder);
2821 } catch (Exception e) {
2822 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2823 responseBuilder.setResponseCode("500");
2824 responseBuilder.setResponseMessage(e.getMessage());
2825 responseBuilder.setAckFinalIndicator("Y");
2826 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2827 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2828 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2829 return Futures.immediateFuture(rpcResult);
2833 responseBuilder.setResponseCode(responseObject.getStatusCode());
2834 responseBuilder.setAckFinalIndicator(ackFinal);
2835 trySetResponseMessage(responseBuilder, responseObject);
2836 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2837 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2839 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2840 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2841 return Futures.immediateFuture(rpcResult);
2844 private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2845 return input == null || input.getPreloadNetworkTopologyInformation() == null
2846 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2849 private boolean hasInvalidPreloadId(String preloadId) {
2850 return preloadId == null || preloadId.length() == 0;
2853 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2854 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2855 if (input.getSdncRequestHeader() != null) {
2856 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2860 private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2861 ResponseObject responseObject) {
2863 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2865 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2866 } catch (Exception e) {
2867 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2868 responseObject.setMessage(e.getMessage());
2869 responseObject.setStatusCode("500");
2872 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2873 responseObject.setStatusCode("503");
2875 } catch (Exception e) {
2876 responseObject.setMessage(e.getMessage());
2877 responseObject.setStatusCode("500");
2878 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2884 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2885 ResponseObject responseObject) {
2886 if (responseObject.getMessage() != null) {
2887 if (!responseObject.getMessage().isEmpty()) {
2888 responseBuilder.setResponseMessage(responseObject.getMessage());
2893 private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2894 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2895 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2896 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2897 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2902 public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2903 PreloadVfModuleTopologyOperationInput input) {
2905 final String svcOperation = "preload-vf-module-topology-operation";
2906 PreloadData preloadData;
2907 Properties properties = new Properties();
2909 log.info(CALLED_STR, svcOperation);
2910 // create a new response object
2911 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2913 if (hasInvalidPreloadVfModule(input)) {
2915 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2917 responseBuilder.setResponseCode("403");
2918 responseBuilder.setResponseMessage(
2919 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2920 responseBuilder.setAckFinalIndicator("Y");
2922 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2923 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2925 return Futures.immediateFuture(rpcResult);
2928 // Grab the preload ID from the input buffer
2929 String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2930 .getVfModuleTopologyIdentifier().getVfModuleName();
2931 String preloadType = "vf-module";
2933 trySetSvcRequestId(input, responseBuilder);
2935 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2936 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2938 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2939 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2942 // setup a preload-data object builder
2943 // ACTION preload-vf-module-topology-operation
2945 // uses sdnc-request-header;
2946 // uses request-information;
2947 // uses preload-vnf-topology-information;
2949 // uses preload-topology-response-body;
2951 // container preload-data
2952 // uses preload-vf-module-topology-information;
2953 // uses preload-oper-status;
2955 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2956 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2958 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2959 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2960 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2962 // Call SLI sync method
2963 ResponseObject responseObject = new ResponseObject("200", "");
2964 String ackFinal = "Y";
2965 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2967 if (respProps != null) {
2968 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2969 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2970 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2973 if (failed(responseObject)) {
2974 responseBuilder.setResponseCode(responseObject.getStatusCode());
2975 responseBuilder.setResponseMessage(responseObject.getMessage());
2976 responseBuilder.setAckFinalIndicator(ackFinal);
2977 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2978 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2979 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2980 return Futures.immediateFuture(rpcResult);
2983 // Got success from SLI
2985 preloadData = preloadDataBuilder.build();
2986 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2988 // preload-list object
2989 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2990 preloadListBuilder.setPreloadId(preloadId);
2991 preloadListBuilder.setPreloadType(preloadType);
2992 preloadListBuilder.setPreloadData(preloadData);
2994 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2995 log.info(UPDATING_TREE_INFO_MESSAGE);
2996 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2998 tryDeletePreload(input, preloadListBuilder);
3000 } catch (Exception e) {
3001 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
3002 responseBuilder.setResponseCode("500");
3003 responseBuilder.setResponseMessage(e.getMessage());
3004 responseBuilder.setAckFinalIndicator("Y");
3005 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
3006 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
3007 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3008 return Futures.immediateFuture(rpcResult);
3012 responseBuilder.setResponseCode(responseObject.getStatusCode());
3013 responseBuilder.setAckFinalIndicator(ackFinal);
3014 trySetResponseMessage(responseBuilder, responseObject);
3015 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
3016 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
3018 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
3019 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3020 return Futures.immediateFuture(rpcResult);
3023 private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
3024 return input == null || input.getPreloadVfModuleTopologyInformation() == null
3025 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
3026 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
3027 .getVfModuleTopologyIdentifier() == null
3028 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
3029 .getVfModuleName() == null;
3032 private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
3033 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
3034 if (input.getSdncRequestHeader() != null) {
3035 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3039 private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
3040 ResponseObject responseObject) {
3041 if (responseObject.getMessage() != null) {
3042 if (!responseObject.getMessage().isEmpty()) {
3043 responseBuilder.setResponseMessage(responseObject.getMessage());
3048 private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
3049 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
3050 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
3051 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
3052 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
3057 public ListenableFuture<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
3058 GenericConfigurationTopologyOperationInput input) {
3060 final String svcOperation = "generic-configuration-topology-operation";
3061 ServiceData serviceData;
3062 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3063 Properties parms = new Properties();
3065 log.info(CALLED_STR, svcOperation);
3066 // create a new response object
3067 GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
3069 if (hasInvalidService(input)) {
3070 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3071 responseBuilder.setResponseCode("404");
3072 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3073 responseBuilder.setAckFinalIndicator("Y");
3075 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3076 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3079 return Futures.immediateFuture(rpcResult);
3082 // Grab the service instance ID from the input buffer
3083 String siid = input.getServiceInformation().getServiceInstanceId();
3085 trySetSvcRequestId(input, responseBuilder);
3087 if (hasInvalidConfigurationIdOrType(input)) {
3088 log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
3089 responseBuilder.setResponseCode("404");
3090 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
3091 responseBuilder.setAckFinalIndicator("Y");
3092 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3093 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3095 return Futures.immediateFuture(rpcResult);
3098 // Grab the configuration ID from the input buffer
3099 String configId = input.getConfigurationInformation().getConfigurationId();
3101 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3102 getServiceData(siid, serviceDataBuilder);
3104 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3105 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3107 // Set the serviceStatus based on input
3108 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3109 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3111 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3112 GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
3114 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3116 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3117 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3119 // Call SLI sync method
3121 ResponseObject responseObject = new ResponseObject("200", "");
3122 String ackFinal = "Y";
3123 String serviceObjectPath = "";
3124 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3126 if (respProps != null) {
3127 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3128 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3129 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3130 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3133 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3134 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3135 serviceStatusBuilder.setRpcName(svcOperation);
3137 if (failed(responseObject)) {
3138 responseBuilder.setResponseCode(responseObject.getStatusCode());
3139 responseBuilder.setResponseMessage(responseObject.getMessage());
3140 responseBuilder.setAckFinalIndicator(ackFinal);
3142 ServiceBuilder serviceBuilder = new ServiceBuilder();
3143 serviceBuilder.setServiceInstanceId(siid);
3144 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3146 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3147 } catch (Exception e) {
3148 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3150 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3152 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3153 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3156 return Futures.immediateFuture(rpcResult);
3159 // Got success from SLI
3161 serviceData = serviceDataBuilder.build();
3164 ServiceBuilder serviceBuilder = new ServiceBuilder();
3165 serviceBuilder.setServiceData(serviceData);
3166 serviceBuilder.setServiceInstanceId(siid);
3167 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3168 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3170 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3171 serviceResponseInformationBuilder.setInstanceId(siid);
3172 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3173 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3174 GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
3175 gcResponseInformationBuilder.setInstanceId(configId);
3176 responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
3178 } catch (Exception e) {
3179 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3180 responseBuilder.setResponseCode("500");
3181 responseBuilder.setResponseMessage(e.getMessage());
3182 responseBuilder.setAckFinalIndicator("Y");
3183 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3184 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3187 return Futures.immediateFuture(rpcResult);
3191 responseBuilder.setResponseCode(responseObject.getStatusCode());
3192 responseBuilder.setAckFinalIndicator(ackFinal);
3193 trySetResponseMessage(responseBuilder, responseObject);
3194 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3195 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3197 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3198 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3200 return Futures.immediateFuture(rpcResult);
3203 private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
3204 return input == null || input.getServiceInformation() == null
3205 || input.getServiceInformation().getServiceInstanceId() == null
3206 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3209 private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
3210 GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
3211 if (input.getSdncRequestHeader() != null) {
3212 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3216 private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
3217 return input.getConfigurationInformation() == null
3218 || input.getConfigurationInformation().getConfigurationId() == null
3219 || input.getConfigurationInformation().getConfigurationType() == null;
3222 private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
3223 ResponseObject responseObject) {
3224 if (responseObject.getMessage() != null) {
3225 if (!responseObject.getMessage().isEmpty()) {
3226 responseBuilder.setResponseMessage(responseObject.getMessage());
3232 public ListenableFuture<RpcResult<GenericConfigurationNotificationOutput>> genericConfigurationNotification(
3233 GenericConfigurationNotificationInput input) {
3235 final String svcOperation = "generic-configuration-notification";
3236 ServiceData serviceData;
3237 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3238 Properties parms = new Properties();
3240 log.info(CALLED_STR, svcOperation);
3242 // Grab the service instance ID from the input buffer
3243 String siid = input.getServiceInformation().getServiceInstanceId();
3245 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3246 getServiceData(siid, serviceDataBuilder);
3248 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3249 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3251 // Set the serviceStatus based on input
3252 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3253 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3255 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3256 GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
3258 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3260 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3261 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3263 // Call SLI sync method
3265 ResponseObject responseObject = new ResponseObject("200", "");
3266 String ackFinal = "Y";
3267 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3269 if (respProps != null) {
3270 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3271 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3272 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3275 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3276 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3277 serviceStatusBuilder.setRpcName(svcOperation);
3279 if (failed(responseObject)) {
3280 ServiceBuilder serviceBuilder = new ServiceBuilder();
3281 serviceBuilder.setServiceInstanceId(siid);
3282 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3284 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3285 } catch (Exception e) {
3286 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3289 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3292 return Futures.immediateFuture(rpcResult);
3295 // Got success from SLI
3297 serviceData = serviceDataBuilder.build();
3300 ServiceBuilder serviceBuilder = new ServiceBuilder();
3301 serviceBuilder.setServiceData(serviceData);
3302 serviceBuilder.setServiceInstanceId(siid);
3303 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3304 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3306 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3307 serviceResponseInformationBuilder.setInstanceId(siid);
3309 } catch (Exception e) {
3310 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3311 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3314 return Futures.immediateFuture(rpcResult);
3318 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3320 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3323 return Futures.immediateFuture(rpcResult);
3327 public ListenableFuture<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
3328 GetpathsegmentTopologyOperationInput input) {
3330 final String svcOperation = "getpathsegment-topology-operation";
3331 ServiceData serviceData;
3332 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3333 Properties parms = new Properties();
3335 log.info(CALLED_STR, svcOperation);
3336 // create a new response object
3337 GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
3339 if (hasInvalidService(input)) {
3340 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3341 responseBuilder.setResponseCode("404");
3342 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3343 responseBuilder.setAckFinalIndicator("Y");
3345 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3346 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3348 return Futures.immediateFuture(rpcResult);
3351 // Grab the service instance ID from the input buffer
3352 String siid = input.getServiceInformation().getServiceInstanceId();
3354 trySetSvcRequestId(input, responseBuilder);
3356 if (hasInvalidOnapModelInformation(input)) {
3357 log.debug("exiting {} because no model-uuid provided", svcOperation);
3358 responseBuilder.setResponseCode("404");
3359 responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
3360 responseBuilder.setAckFinalIndicator("Y");
3361 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3362 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3363 return Futures.immediateFuture(rpcResult);
3366 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3367 getServiceData(siid, serviceDataBuilder);
3369 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3370 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3372 // Set the serviceStatus based on input
3373 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3374 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3376 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3377 GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
3379 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3381 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3382 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3384 // Call SLI sync method
3386 ResponseObject responseObject = new ResponseObject("200", "");
3387 String ackFinal = "Y";
3388 String serviceObjectPath = null;
3389 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3391 if (respProps != null) {
3392 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3393 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3394 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3395 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3398 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3399 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3400 serviceStatusBuilder.setRpcName(svcOperation);
3402 if (failed(responseObject)) {
3403 responseBuilder.setResponseCode(responseObject.getStatusCode());
3404 responseBuilder.setResponseMessage(responseObject.getMessage());
3405 responseBuilder.setAckFinalIndicator(ackFinal);
3407 ServiceBuilder serviceBuilder = new ServiceBuilder();
3408 serviceBuilder.setServiceInstanceId(siid);
3409 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3411 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3412 } catch (Exception e) {
3413 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3415 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3417 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3418 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3420 return Futures.immediateFuture(rpcResult);
3423 // Got success from SLI
3425 serviceData = serviceDataBuilder.build();
3426 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3429 ServiceBuilder serviceBuilder = new ServiceBuilder();
3430 serviceBuilder.setServiceData(serviceData);
3431 serviceBuilder.setServiceInstanceId(siid);
3432 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3433 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3435 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3436 serviceResponseInformationBuilder.setInstanceId(siid);
3437 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3438 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3440 } catch (Exception e) {
3441 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3442 responseBuilder.setResponseCode("500");
3443 responseBuilder.setResponseMessage(e.getMessage());
3444 responseBuilder.setAckFinalIndicator("Y");
3445 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3446 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3448 return Futures.immediateFuture(rpcResult);
3452 responseBuilder.setResponseCode(responseObject.getStatusCode());
3453 responseBuilder.setAckFinalIndicator(ackFinal);
3454 trySetResponseMessage(responseBuilder, responseObject);
3455 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3456 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3458 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3459 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3461 return Futures.immediateFuture(rpcResult);
3464 private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
3465 return input == null || input.getServiceInformation() == null
3466 || input.getServiceInformation().getServiceInstanceId() == null
3467 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3470 private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
3471 GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
3472 if (input.getSdncRequestHeader() != null) {
3473 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3477 private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
3478 return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
3479 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
3482 private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
3483 ResponseObject responseObject) {
3484 if (responseObject.getMessage() != null) {
3485 if (!responseObject.getMessage().isEmpty()) {
3486 responseBuilder.setResponseMessage(responseObject.getMessage());
3492 public ListenableFuture<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
3493 PolicyUpdateNotifyOperationInput input) {
3495 final String svcOperation = "policy-update-notify-operation";
3496 Properties parms = new Properties();
3498 log.info(CALLED_STR, svcOperation);
3500 // create a new response object
3501 PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
3503 // Make sure we have a valid input
3504 if (hasInvalidInput(input)) {
3505 log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
3506 responseBuilder.setErrorCode("404");
3507 responseBuilder.setErrorMsg("Invalid input, missing input data");
3508 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3509 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3510 return Futures.immediateFuture(rpcResult);
3513 log.info("Adding INPUT data for {} input: {}", svcOperation, input);
3514 PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
3515 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3517 // Call SLI sync method
3518 ResponseObject responseObject = new ResponseObject("200", "");
3519 String ackFinal = "Y";
3520 String serviceObjectPath = null;
3521 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
3523 if (respProps != null) {
3524 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3525 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3526 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3527 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3530 if (failed(responseObject)) {
3531 responseBuilder.setErrorCode(responseObject.getStatusCode());
3532 responseBuilder.setErrorMsg(responseObject.getMessage());
3533 log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
3535 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3536 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3538 return Futures.immediateFuture(rpcResult);
3541 // Got success from SLI
3542 responseBuilder.setErrorCode(responseObject.getStatusCode());
3543 if (responseObject.getMessage() != null) {
3544 responseBuilder.setErrorMsg(responseObject.getMessage());
3546 log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
3547 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3548 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3550 return Futures.immediateFuture(rpcResult);
3553 private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
3554 return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3558 public ListenableFuture<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3559 final PortMirrorTopologyOperationInput input) {
3561 final String svcOperation = "port-mirror-topology-operation";
3562 ServiceData serviceData = null;
3563 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3564 Properties properties = new Properties();
3566 log.info(CALLED_STR, svcOperation);
3568 // create a new response object
3569 PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3571 if (hasInvalidService(input)) {
3572 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3573 responseBuilder.setResponseCode("404");
3574 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3575 responseBuilder.setAckFinalIndicator("Y");
3576 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3577 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3579 return Futures.immediateFuture(rpcResult);
3582 if (hasInvalidConfigurationId(input)) {
3583 log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3584 responseBuilder.setResponseCode("404");
3585 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3586 responseBuilder.setAckFinalIndicator("Y");
3587 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3588 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3589 return Futures.immediateFuture(rpcResult);
3592 // Grab the service instance ID from the input buffer
3593 String siid = input.getServiceInformation().getServiceInstanceId();
3595 trySetSvcRequestId(input, responseBuilder);
3597 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3598 getServiceData(siid, serviceDataBuilder);
3600 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3601 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3603 // Set the serviceStatus based on input
3604 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3605 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3607 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3608 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3609 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3611 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3612 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3614 // Call SLI sync method
3615 ResponseObject responseObject = new ResponseObject("200", "");
3616 String ackFinal = "Y";
3617 String serviceObjectPath = null;
3618 String portMirrorObjectPath = null;
3619 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3621 if (respProps != null) {
3622 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3623 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3624 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3625 serviceObjectPath = respProps.getProperty("service-object-path");
3626 portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3629 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3630 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3631 serviceStatusBuilder.setRpcName(svcOperation);
3633 if (failed(responseObject)) {
3634 responseBuilder.setResponseCode(responseObject.getStatusCode());
3635 responseBuilder.setResponseMessage(responseObject.getMessage());
3636 responseBuilder.setAckFinalIndicator(ackFinal);
3638 ServiceBuilder serviceBuilder = new ServiceBuilder();
3639 serviceBuilder.setServiceInstanceId(siid);
3640 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3642 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3643 } catch (Exception e) {
3644 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3646 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3648 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3649 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3652 return Futures.immediateFuture(rpcResult);
3655 // Got success from SLI
3657 serviceData = serviceDataBuilder.build();
3658 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3661 ServiceBuilder serviceBuilder = new ServiceBuilder();
3662 serviceBuilder.setServiceData(serviceData);
3663 serviceBuilder.setServiceInstanceId(siid);
3664 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3665 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3667 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3668 // Only update operational tree on activate or delete
3669 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3670 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3671 log.info(UPDATING_TREE_INFO_MESSAGE);
3672 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3676 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3677 serviceResponseInformationBuilder.setInstanceId(siid);
3678 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3679 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3680 PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3681 portMirrorResponseInformationBuilder
3682 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3683 portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3684 responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3686 } catch (Exception e) {
3687 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3688 responseBuilder.setResponseCode("500");
3689 responseBuilder.setResponseMessage(e.getMessage());
3690 responseBuilder.setAckFinalIndicator("Y");
3691 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3692 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3693 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3694 return Futures.immediateFuture(rpcResult);
3698 responseBuilder.setResponseCode(responseObject.getStatusCode());
3699 responseBuilder.setAckFinalIndicator(ackFinal);
3700 trySetResponseMessage(responseBuilder, responseObject);
3701 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3702 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3704 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3705 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3707 if (ackFinal.equals("N")) {
3708 // Spawn background thread to invoke the Async DG
3709 Runnable backgroundThread = new Runnable() {
3711 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3712 processAsyncPortMirrorTopologyOperation(input);
3715 new Thread(backgroundThread).start();
3719 return Futures.immediateFuture(rpcResult);
3722 private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3723 return input == null || input.getServiceInformation() == null
3724 || input.getServiceInformation().getServiceInstanceId() == null
3725 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3728 private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3729 return input.getConfigurationInformation() == null
3730 || input.getConfigurationInformation().getConfigurationId() == null
3731 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3734 private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3735 PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3736 if (input.getSdncRequestHeader() != null) {
3737 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3741 private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3742 ResponseObject responseObject) {
3743 if (responseObject.getMessage() != null) {
3744 if (!responseObject.getMessage().isEmpty()) {
3745 responseBuilder.setResponseMessage(responseObject.getMessage());
3750 public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3751 log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3753 final String svcOperation = "port-mirror-topology-operation-async";
3754 ServiceData serviceData = null;
3755 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3756 Properties parms = new Properties();
3758 log.info(CALLED_STR, svcOperation);
3760 // Grab the service instance ID from the input buffer
3761 String siid = input.getServiceInformation().getServiceInstanceId();
3763 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3764 getServiceData(siid, serviceDataBuilder);
3766 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3767 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3769 // Set the serviceStatus based on input
3770 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3771 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3773 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3774 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3775 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3777 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3778 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3780 // Call SLI sync method
3781 ResponseObject responseObject = new ResponseObject("200", "");
3782 String ackFinal = "Y";
3783 String serviceObjectPath = null;
3784 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3786 if (respProps != null) {
3787 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3788 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3789 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3792 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3793 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3794 serviceStatusBuilder.setRpcName(svcOperation);
3796 if (failed(responseObject)) {
3797 ServiceBuilder serviceBuilder = new ServiceBuilder();
3798 serviceBuilder.setServiceInstanceId(siid);
3799 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3801 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3802 } catch (Exception e) {
3803 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3810 // Got success from SLI
3812 serviceData = serviceDataBuilder.build();
3813 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3816 ServiceBuilder serviceBuilder = new ServiceBuilder();
3817 serviceBuilder.setServiceData(serviceData);
3818 serviceBuilder.setServiceInstanceId(siid);
3819 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3820 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3822 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3823 // Only update operational tree on activate or delete
3824 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3825 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3826 log.info(UPDATING_TREE_INFO_MESSAGE);
3827 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3831 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3832 serviceResponseInformationBuilder.setInstanceId(siid);
3833 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3835 } catch (Exception e) {
3836 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3841 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3847 public ListenableFuture<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(
3848 VnfGetResourceRequestInput input) {
3850 final String svcOperation = "vnf-get-resource-request";
3851 ServiceData serviceData;
3852 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3853 Properties parms = new Properties();
3855 log.info(CALLED_STR, svcOperation);
3856 // create a new response object
3857 VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3859 if (hasInvalidService(input)) {
3860 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3861 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3862 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3864 return Futures.immediateFuture(rpcResult);
3867 // Grab the service instance ID from the input buffer
3868 String siid = input.getServiceInformation().getServiceInstanceId();
3870 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3871 getServiceData(siid, serviceDataBuilder);
3873 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3874 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3876 // Set the serviceStatus based on input
3877 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3878 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3880 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3881 VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3882 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3884 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3885 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3887 // Call SLI sync method
3889 ResponseObject responseObject = new ResponseObject("200", "");
3890 String ackFinal = "Y";
3891 String serviceObjectPath = null;
3892 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3894 if (respProps != null) {
3895 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3896 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3897 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3898 serviceObjectPath = respProps.getProperty("service-object-path");
3901 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3902 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3903 serviceStatusBuilder.setRpcName(svcOperation);
3905 if (failed(responseObject)) {
3906 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3907 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3908 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3910 return Futures.immediateFuture(rpcResult);
3913 // Got success from SLI
3914 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3916 if (respProps != null) {
3917 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3920 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3921 .withResult(responseBuilder.build()).build();
3924 return Futures.immediateFuture(rpcResult);
3927 private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3928 return input == null || input.getServiceInformation() == null
3929 || input.getServiceInformation().getServiceInstanceId() == null
3930 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3934 public ListenableFuture<RpcResult<CollectPerformanceDataOutput>> collectPerformanceData(CollectPerformanceDataInput input) {
3935 final String svcOperation = "performance-data-collector";
3936 Properties parms = new Properties();
3938 log.info(CALLED_STR, svcOperation);
3939 // create a new response object
3940 CollectPerformanceDataOutputBuilder responseBuilder = new CollectPerformanceDataOutputBuilder();
3942 if (hasInvalidService(input)) {
3943 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3944 RpcResult<CollectPerformanceDataOutput> rpcResult = RpcResultBuilder
3945 .<CollectPerformanceDataOutput>status(true).withResult(responseBuilder.build()).build();
3947 return Futures.immediateFuture(rpcResult);
3950 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3951 serviceDataBuilder.setControllerIpv4Address(input.getControllerIpv4Address());
3953 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3955 log.info(ADDING_INPUT_DATA_LOG, svcOperation, input.getControllerIpv4Address(), input);
3956 CollectPerformanceDataInputBuilder inputBuilder = new CollectPerformanceDataInputBuilder(input);
3957 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3959 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, input.getControllerIpv4Address(), operDataBuilder.build());
3960 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3962 // Call SLI sync method
3963 ResponseObject responseObject = new ResponseObject("200", "");
3964 String ackFinal = "Y";
3965 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3967 if (respProps != null) {
3968 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3969 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3970 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3973 if (failed(responseObject)) {
3974 responseBuilder.setResponseCode(responseObject.getStatusCode());
3975 responseBuilder.setResponseMessage(responseObject.getMessage());
3976 responseBuilder.setAckFinalIndicator(ackFinal);
3978 log.error(RETURNED_FAILED_MESSAGE, svcOperation, input.getControllerIpv4Address(), responseBuilder.build());
3979 RpcResult<CollectPerformanceDataOutput> rpcResult = RpcResultBuilder
3980 .<CollectPerformanceDataOutput>status(true).withResult(responseBuilder.build()).build();
3982 return Futures.immediateFuture(rpcResult);
3985 // Got success from SLI
3986 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, input.getControllerIpv4Address(), responseBuilder.build());
3988 if (respProps != null) {
3989 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3992 RpcResult<CollectPerformanceDataOutput> rpcResult = RpcResultBuilder.<CollectPerformanceDataOutput>status(true)
3993 .withResult(responseBuilder.build()).build();
3996 return Futures.immediateFuture(rpcResult);
3999 private boolean hasInvalidService(CollectPerformanceDataInput input) {
4000 return input == null || input.getControllerIpv4Address() == null;