1 package org.onap.sdnc.northbound;
3 import com.google.common.base.Optional;
4 import com.google.common.util.concurrent.CheckedFuture;
5 import com.google.common.util.concurrent.Futures;
6 import com.google.common.util.concurrent.ListenableFuture;
8 import java.text.DateFormat;
9 import java.text.SimpleDateFormat;
10 import java.util.Date;
11 import java.util.Properties;
12 import java.util.TimeZone;
13 import java.util.concurrent.ExecutionException;
14 import java.util.concurrent.ExecutorService;
15 import java.util.concurrent.Executors;
16 import java.util.concurrent.Future;
18 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
19 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
20 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
23 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
24 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
25 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
26 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInput;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInputBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationInput;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationInputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationOutput;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationInput;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationInputBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationOutput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationOutputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationInput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationInputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationOutput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationOutputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationInput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationInputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationOutput;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationOutputBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationInput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationInputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationOutput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadInformation;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadInformationBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationInput;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationInputBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationOutput;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationOutputBuilder;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestInput;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestInputBuilder;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestOutput;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestOutputBuilder;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.connection.attachment.response.information.ConnectionAttachmentResponseInformationBuilder;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.gc.response.information.GcResponseInformationBuilder;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.port.mirror.response.information.PortMirrorResponseInformationBuilder;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadList;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListBuilder;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListKey;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vf.module.response.information.VfModuleResponseInformationBuilder;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vnf.response.information.VnfResponseInformationBuilder;
126 import org.opendaylight.yangtools.yang.binding.DataObject;
127 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
128 import org.opendaylight.yangtools.yang.common.RpcResult;
129 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
130 import org.slf4j.Logger;
131 import org.slf4j.LoggerFactory;
134 * Defines a base implementation for your provider. This class extends from a
135 * helper class which provides storage for the most commonly used components of
136 * the MD-SAL. Additionally the base class provides some basic logging and
137 * initialization / clean up methods.
139 * To use this, copy and paste (overwrite) the following method into the
140 * TestApplicationProviderModule class which is auto generated under
141 * src/main/java in this project (created only once during first compilation):
146 * public java.lang.AutoCloseable createInstance() {
148 * // final GENERIC-RESOURCE-APIProvider provider = new
149 * // GENERIC-RESOURCE-APIProvider();
150 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
151 * provider.setDataBroker(getDataBrokerDependency());
152 * provider.setNotificationService(getNotificationServiceDependency());
153 * provider.setRpcRegistry(getRpcRegistryDependency());
154 * provider.initialize();
155 * return new AutoCloseable() {
158 * public void close() throws Exception {
159 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
160 * // BROKER/NOTIFICATION
161 * // SERVIE/RPC REGISTRY
170 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
172 protected static final String APP_NAME = "generic-resource-api";
173 private static final String CALLED_STR = "{} called.";
174 private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
175 protected static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
176 private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
177 private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
178 private static final String OPERATIONAL_DATA_PARAM = "operational-data";
179 protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
180 private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
181 private static final String ERROR_CODE_PARAM = "error-code";
182 private static final String ERROR_MESSAGE_PARAM = "error-message";
183 private static final String ACK_FINAL_PARAM = "ack-final";
184 private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
185 private static final String NETWORK_OBJECT_PATH_PARAM = "network-object-path";
186 private static final String VNF_OBJECT_PATH_PARAM = "vnf-object-path";
187 private static final String VF_MODULE_OBJECT_PATH_PARAM = "vf-module-object-path";
188 private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
189 private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
190 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
191 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
192 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
193 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
194 private static final String NON_NULL_PARAM = "non-null";
195 private static final String NULL_PARAM = "null";
196 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
197 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
198 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
199 protected static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
200 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
201 private static final String ERROR_NETWORK_ID = "error";
202 private static final String BACKGROUND_THREAD_STARTED_MESSAGE = "Start background thread";
203 private static final String BACKGROUND_THREAD_INFO = "Background thread: input conf_id is {}";
205 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
206 private final ExecutorService executor;
207 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
209 protected DataBroker dataBroker;
210 protected NotificationPublishService notificationService;
211 protected RpcProviderRegistry rpcRegistry;
212 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
214 public GenericResourceApiProvider(DataBroker dataBroker, NotificationPublishService notificationPublishService,
215 RpcProviderRegistry rpcProviderRegistry, GenericResourceApiSvcLogicServiceClient client) {
216 log.info("Creating provider for {}", APP_NAME);
217 executor = Executors.newFixedThreadPool(1);
218 setDataBroker(dataBroker);
219 setNotificationService(notificationPublishService);
220 setRpcRegistry(rpcProviderRegistry);
221 svcLogicClient = client;
226 public void initialize() {
227 log.info("Initializing provider for {}", APP_NAME);
228 // Create the top level containers
231 GenericResourceApiUtil.loadProperties();
232 } catch (Exception e) {
233 log.error("Caught Exception while trying to load properties file", e);
236 log.info("Initialization complete for {}", APP_NAME);
239 protected void initializeChild() {
240 // Override if you have custom initialization intelligence
244 public void close() throws Exception {
245 log.info("Closing provider for {}", APP_NAME);
247 rpcRegistration.close();
248 log.info("Successfully closed provider for {}", APP_NAME);
251 private static class Iso8601Util {
253 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
254 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
256 private Iso8601Util() {
260 dateFormat.setTimeZone(timeZone);
263 private static String now() {
264 return dateFormat.format(new Date());
268 public void setDataBroker(DataBroker dataBroker) {
269 this.dataBroker = dataBroker;
270 if (log.isDebugEnabled()) {
271 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
275 public void setNotificationService(NotificationPublishService notificationService) {
276 this.notificationService = notificationService;
277 if (log.isDebugEnabled()) {
278 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
282 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
283 this.rpcRegistry = rpcRegistry;
284 if (log.isDebugEnabled()) {
285 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
289 private void createContainers() {
291 final WriteTransaction t = dataBroker.newReadWriteTransaction();
293 // Create the service-instance container
294 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
295 new ServicesBuilder().build());
296 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
297 new ServicesBuilder().build());
299 // Create the PreloadInformation container
300 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadInformation.class),
301 new PreloadInformationBuilder().build());
302 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadInformation.class),
303 new PreloadInformationBuilder().build());
306 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
308 log.info("Create containers succeeded!");
310 } catch (InterruptedException | ExecutionException e) {
311 log.error("Create containers failed: ", e);
315 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
317 serviceStatusBuilder.setResponseCode(errorCode);
318 serviceStatusBuilder.setResponseMessage(errorMessage);
319 serviceStatusBuilder.setFinalIndicator(ackFinal);
320 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
323 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
324 if (requestInformation != null && requestInformation.getRequestAction() != null) {
325 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
329 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
330 if (requestHeader != null && requestHeader.getSvcAction() != null) {
331 switch (requestHeader.getSvcAction()) {
333 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
336 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
339 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
342 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
345 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
348 serviceStatusBuilder.setRpcAction(RpcAction.Create);
351 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
357 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
359 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
362 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
363 // See if any data exists yet for this siid, if so grab it.
364 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier.builder(Services.class)
365 .child(Service.class, new ServiceKey(siid)).build();
367 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
368 Optional<Service> data = Optional.absent();
370 data = readTx.read(type, serviceInstanceIdentifier).get();
371 } catch (InterruptedException | ExecutionException e) {
372 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
375 if (data != null && data.isPresent()) {
376 ServiceData serviceData = data.get().getServiceData();
377 if (serviceData != null) {
378 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
379 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
380 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
381 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
382 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
383 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
384 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
385 serviceDataBuilder.setNetworks(serviceData.getNetworks());
386 serviceDataBuilder.setVnfs(serviceData.getVnfs());
387 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
388 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
389 serviceDataBuilder.setNetworkInstanceGroups(serviceData.getNetworkInstanceGroups());
390 serviceDataBuilder.setVnfcInstanceGroups(serviceData.getVnfcInstanceGroups());
391 serviceDataBuilder.setForwardingPaths(serviceData.getForwardingPaths());
392 serviceDataBuilder.setProvidedConfigurations(serviceData.getProvidedConfigurations());
393 // service-instance-id needs to be set
395 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
398 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
402 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
403 // Each entry will be identifiable by a unique key, we have to create that
405 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
406 .child(Service.class, entry.key()).build();
408 trySaveEntry(entry, merge, storeType, path);
411 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
412 InstanceIdentifier<T> path) {
416 save(entry, merge, storeType, path);
418 } catch (OptimisticLockFailedException e) {
420 log.debug("Got OptimisticLockFailedException on last try - failing ");
421 throw new IllegalStateException(e);
423 log.debug("Got OptimisticLockFailedException - trying again ");
424 } catch (TransactionCommitFailedException ex) {
425 log.debug("Update DataStore failed");
426 throw new IllegalStateException(ex);
431 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
432 InstanceIdentifier<T> path) throws TransactionCommitFailedException {
433 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
435 tx.merge(storeType, path, entry);
437 tx.put(storeType, path, entry);
439 tx.submit().checkedGet();
440 log.debug("Update DataStore succeeded");
443 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
444 // Each entry will be identifiable by a unique key, we have to create
446 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
447 .child(Service.class, entry.key()).build();
449 tryDeleteEntry(storeType, path);
452 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
456 delete(storeType, path);
458 } catch (OptimisticLockFailedException e) {
460 log.debug("Got OptimisticLockFailedException on last try - failing ");
461 throw new IllegalStateException(e);
463 log.debug("Got OptimisticLockFailedException - trying again ");
464 } catch (TransactionCommitFailedException ex) {
465 log.debug("Update DataStore failed");
466 throw new IllegalStateException(ex);
471 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
472 throws TransactionCommitFailedException {
473 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
474 tx.delete(storeType, path);
475 tx.submit().checkedGet();
476 log.debug("DataStore delete succeeded");
479 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
481 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
484 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
485 LogicalDatastoreType type) {
486 // See if any data exists yet for this name/type, if so grab it.
487 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier
488 .<PreloadInformation>builder(PreloadInformation.class)
489 .child(PreloadList.class, new PreloadListKey(preloadName, preloadType)).build();
490 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
491 Optional<PreloadList> data = null;
493 data = (Optional<PreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
494 } catch (InterruptedException | ExecutionException e) {
495 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
498 if (data != null && data.isPresent()) {
499 PreloadData preloadData = data.get().getPreloadData();
500 if (preloadData != null) {
501 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
504 .setPreloadVfModuleTopologyInformation(preloadData.getPreloadVfModuleTopologyInformation());
506 .setPreloadNetworkTopologyInformation(preloadData.getPreloadNetworkTopologyInformation());
507 preloadDataBuilder.setPreloadOperStatus(preloadData.getPreloadOperStatus());
509 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
512 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
516 private void savePreloadList(final PreloadList entry, boolean merge, LogicalDatastoreType storeType)
517 throws IllegalStateException {
519 // Each entry will be identifiable by a unique key, we have to create that
521 InstanceIdentifier.InstanceIdentifierBuilder<PreloadList> preloadListBuilder = InstanceIdentifier
522 .<PreloadInformation>builder(PreloadInformation.class).child(PreloadList.class, entry.key());
523 InstanceIdentifier<PreloadList> path = preloadListBuilder.build();
527 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
529 tx.merge(storeType, path, entry);
531 tx.put(storeType, path, entry);
533 tx.submit().checkedGet();
534 log.debug("Update DataStore succeeded");
536 } catch (final TransactionCommitFailedException e) {
537 if (e instanceof OptimisticLockFailedException) {
539 log.debug("Got OptimisticLockFailedException on last try - failing ");
540 throw new IllegalStateException(e);
542 log.debug("Got OptimisticLockFailedException - trying again ");
544 log.debug("Update DataStore failed");
545 throw new IllegalStateException(e);
551 private void deletePreloadList(final PreloadList entry, LogicalDatastoreType storeType) {
552 // Each entry will be identifiable by a unique key, we have to create
554 InstanceIdentifier<PreloadList> path = InstanceIdentifier.builder(PreloadInformation.class)
555 .child(PreloadList.class, entry.key()).build();
557 tryDeletePreloadListEntry(storeType, path);
560 private void tryDeletePreloadListEntry(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path) {
564 deletePreloadList(storeType, path);
566 } catch (OptimisticLockFailedException e) {
568 log.debug("Got OptimisticLockFailedException on last try - failing ");
569 throw new IllegalStateException(e);
571 log.debug("Got OptimisticLockFailedException - trying again ");
572 } catch (TransactionCommitFailedException ex) {
573 log.debug("Update DataStore failed");
574 throw new IllegalStateException(ex);
579 private void deletePreloadList(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path)
580 throws TransactionCommitFailedException {
581 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
582 tx.delete(storeType, path);
583 tx.submit().checkedGet();
584 log.debug("DataStore delete succeeded");
588 public ListenableFuture<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
589 ServiceTopologyOperationInput input) {
591 final String svcOperation = "service-topology-operation";
592 ServiceData serviceData;
593 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
594 Properties parms = new Properties();
596 log.info(CALLED_STR, svcOperation);
597 // create a new response object
598 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
600 if (hasInvalidServiceId(input)) {
601 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
602 responseBuilder.setResponseCode("404");
603 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
604 responseBuilder.setAckFinalIndicator("Y");
606 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
607 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
609 return Futures.immediateFuture(rpcResult);
612 // Grab the service instance ID from the input buffer
613 String siid = input.getServiceInformation().getServiceInstanceId();
615 trySetSvcRequestId(input, responseBuilder);
617 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
618 getServiceData(siid, serviceDataBuilder);
620 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
621 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
623 // Set the serviceStatus based on input
624 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
625 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
628 * // setup a service-data object builder // ACTION service-topology-operation
629 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
630 * topology-response-common; // uses service-response-information;
633 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
634 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
635 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
637 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
638 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
640 // Call SLI sync method
641 ResponseObject responseObject = new ResponseObject("200", "");
642 String ackFinal = "Y";
643 String serviceObjectPath = null;
644 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
646 if (respProps != null) {
647 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
648 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
649 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
650 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
653 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
654 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
655 serviceStatusBuilder.setRpcName(svcOperation);
657 if (failed(responseObject)) {
658 responseBuilder.setResponseCode(responseObject.getStatusCode());
659 responseBuilder.setResponseMessage(responseObject.getMessage());
660 responseBuilder.setAckFinalIndicator(ackFinal);
662 ServiceBuilder serviceBuilder = new ServiceBuilder();
663 serviceBuilder.setServiceInstanceId(siid);
664 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
666 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
667 } catch (Exception e) {
668 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
670 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
672 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
673 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
675 return Futures.immediateFuture(rpcResult);
678 // Got success from SLI
680 serviceData = serviceDataBuilder.build();
681 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
684 ServiceBuilder serviceBuilder = new ServiceBuilder();
685 serviceBuilder.setServiceData(serviceData);
686 serviceBuilder.setServiceInstanceId(siid);
687 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
688 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
690 tryDeleteService(input, serviceBuilder);
692 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
693 serviceResponseInformationBuilder.setInstanceId(siid);
694 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
695 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
697 } catch (Exception e) {
698 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
699 responseBuilder.setResponseCode("500");
700 responseBuilder.setResponseMessage(e.getMessage());
701 responseBuilder.setAckFinalIndicator("Y");
702 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
704 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
705 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
707 return Futures.immediateFuture(rpcResult);
711 responseBuilder.setResponseCode(responseObject.getStatusCode());
712 responseBuilder.setAckFinalIndicator(ackFinal);
713 trySetResponseMessage(responseBuilder, responseObject);
714 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
715 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
717 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
718 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
720 return Futures.immediateFuture(rpcResult);
723 private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder,
724 ResponseObject responseObject) {
725 if (responseObject.getMessage() != null) {
726 responseBuilder.setResponseMessage(responseObject.getMessage());
730 private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
731 return input == null || input.getServiceInformation() == null
732 || input.getServiceInformation().getServiceInstanceId() == null
733 || input.getServiceInformation().getServiceInstanceId().length() == 0;
736 private void trySetSvcRequestId(ServiceTopologyOperationInput input,
737 ServiceTopologyOperationOutputBuilder responseBuilder) {
738 if (input.getSdncRequestHeader() != null) {
739 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
743 private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
744 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
745 // Only update operational tree on delete
746 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
747 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
748 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
752 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
753 ResponseObject responseObject) {
755 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
757 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
758 } catch (Exception e) {
759 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
760 responseObject.setMessage(e.getMessage());
761 responseObject.setStatusCode("500");
764 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
765 responseObject.setStatusCode("503");
767 } catch (Exception e) {
768 responseObject.setMessage(e.getMessage());
769 responseObject.setStatusCode("500");
770 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
776 private boolean failed(ResponseObject error) {
777 return !error.getStatusCode().isEmpty()
778 && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
781 private boolean isValidRequest(ServiceTopologyOperationInput input) {
782 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
786 public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
788 final String svcOperation = "vnf-topology-operation";
789 ServiceData serviceData;
790 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
791 Properties properties = new Properties();
793 log.info(CALLED_STR, svcOperation);
794 // create a new response object
795 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
797 if (hasInvalidServiceId(input)) {
798 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
799 responseBuilder.setResponseCode("404");
800 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
801 responseBuilder.setAckFinalIndicator("Y");
802 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
803 .withResult(responseBuilder.build()).build();
805 return Futures.immediateFuture(rpcResult);
808 // Grab the service instance ID from the input buffer
809 String siid = input.getServiceInformation().getServiceInstanceId();
811 trySetSvcRequestId(input, responseBuilder);
813 /* Comment out mandatory check for vnf id for scenario wherein for assign/create request vnf-id is generated by
815 if (hasInvalidVnfId(input)) {
816 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
817 responseBuilder.setResponseCode("404");
818 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
819 responseBuilder.setAckFinalIndicator("Y");
821 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
822 .withResult(responseBuilder.build()).build();
824 return Futures.immediateFuture(rpcResult);
828 String vnfId = input.getVnfInformation().getVnfId();
829 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
830 getServiceData(siid, serviceDataBuilder);
832 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
833 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
835 // Set the serviceStatus based on input
836 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
837 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
840 // setup a service-data object builder
841 // ACTION vnf-topology-operation
843 // USES sdnc-request-header;
844 // USES request-information;
845 // USES service-information;
846 // USES vnf-request-information
848 // USES vnf-topology-response-body;
849 // USES vnf-information
850 // USES service-information
852 // container service-data
853 // uses vnf-configuration-information;
856 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
857 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
858 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
860 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
861 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
863 // Call SLI sync method
865 ResponseObject responseObject = new ResponseObject("200", "");
866 String ackFinal = "Y";
867 String serviceObjectPath = null;
868 String vnfObjectPath = null;
869 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
871 if (respProps != null) {
872 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
873 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
874 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
876 vnfId = respProps.getProperty("vnfId");
878 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
879 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
882 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
883 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
884 serviceStatusBuilder.setRpcName(svcOperation);
886 if (failed(responseObject)) {
887 responseBuilder.setResponseCode(responseObject.getStatusCode());
888 responseBuilder.setResponseMessage(responseObject.getMessage());
889 responseBuilder.setAckFinalIndicator(ackFinal);
891 ServiceBuilder serviceBuilder = new ServiceBuilder();
892 serviceBuilder.setServiceInstanceId(siid);
893 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
895 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
896 trySaveService(input, serviceBuilder);
897 } catch (Exception e) {
898 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
900 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
902 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
903 .withResult(responseBuilder.build()).build();
906 return Futures.immediateFuture(rpcResult);
909 // Got success from SLI
911 serviceData = serviceDataBuilder.build();
912 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
915 ServiceBuilder serviceBuilder = new ServiceBuilder();
916 serviceBuilder.setServiceData(serviceData);
917 serviceBuilder.setServiceInstanceId(siid);
918 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
919 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
921 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
922 // Only update operational tree on Assign
923 log.info(UPDATING_TREE_INFO_MESSAGE);
924 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
927 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
928 serviceResponseInformationBuilder.setInstanceId(siid);
929 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
930 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
932 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
933 vnfResponseInformationBuilder.setInstanceId(vnfId);
934 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
935 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
937 } catch (Exception e) {
938 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
939 responseBuilder.setResponseCode("500");
940 responseBuilder.setResponseMessage(e.getMessage());
941 responseBuilder.setAckFinalIndicator("Y");
942 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
944 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
945 .withResult(responseBuilder.build()).build();
947 return Futures.immediateFuture(rpcResult);
951 responseBuilder.setResponseCode(responseObject.getStatusCode());
952 responseBuilder.setAckFinalIndicator(ackFinal);
953 trySetResponseMessage(responseBuilder, responseObject);
954 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
955 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
957 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
958 .withResult(responseBuilder.build()).build();
961 return Futures.immediateFuture(rpcResult);
964 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
965 ResponseObject responseObject) {
966 if (responseObject.getMessage() != null) {
967 responseBuilder.setResponseMessage(responseObject.getMessage());
971 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
972 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
973 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
975 // Only update operational tree on activate or delete
976 log.info(UPDATING_TREE_INFO_MESSAGE);
977 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
981 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
982 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
983 || input.getVnfInformation().getVnfId().length() == 0;
986 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
987 return input == null || input.getServiceInformation() == null
988 || input.getServiceInformation().getServiceInstanceId() == null
989 || input.getServiceInformation().getServiceInstanceId().length() == 0;
992 private void trySetSvcRequestId(VnfTopologyOperationInput input,
993 VnfTopologyOperationOutputBuilder responseBuilder) {
994 if (input.getSdncRequestHeader() != null) {
995 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
999 private boolean isValidRequest(VnfTopologyOperationInput input) {
1000 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1004 public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1005 VfModuleTopologyOperationInput input) {
1007 final String svcOperation = "vf-module-topology-operation";
1008 ServiceData serviceData;
1009 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1010 Properties parms = new Properties();
1012 log.info(CALLED_STR, svcOperation);
1013 // create a new response object
1014 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1016 if (hasInvalidServiceId(input)) {
1017 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1018 responseBuilder.setResponseCode("403");
1019 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1020 responseBuilder.setAckFinalIndicator("Y");
1022 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1023 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1026 return Futures.immediateFuture(rpcResult);
1029 if (hasInvalidVnfId(input)) {
1030 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1031 responseBuilder.setResponseCode("403");
1032 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1033 responseBuilder.setAckFinalIndicator("Y");
1034 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1035 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1036 return Futures.immediateFuture(rpcResult);
1039 if (hasInvalidVfModuleId(input)) {
1040 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1041 responseBuilder.setResponseCode("403");
1042 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1043 responseBuilder.setAckFinalIndicator("Y");
1045 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1046 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1048 return Futures.immediateFuture(rpcResult);
1051 // Grab the service instance ID from the input buffer
1052 String siid = input.getServiceInformation().getServiceInstanceId();
1053 String vnfId = input.getVnfInformation().getVnfId();
1054 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1056 trySetSvcRequestId(input, responseBuilder);
1058 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1059 getServiceData(siid, serviceDataBuilder);
1061 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1062 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1064 // Set the serviceStatus based on input
1065 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1066 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1069 // setup a service-data object builder
1070 // ACTION vnf-topology-operation
1072 // USES sdnc-request-header;
1073 // USES request-information;
1074 // USES service-information;
1075 // USES vnf-request-information
1077 // USES vnf-topology-response-body;
1078 // USES vnf-information
1079 // USES service-information
1081 // container service-data
1082 // uses vnf-configuration-information;
1083 // uses oper-status;
1085 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1086 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1087 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1089 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1090 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1092 // Call SLI sync method
1094 ResponseObject responseObject = new ResponseObject("200", "");
1095 String ackFinal = "Y";
1096 String serviceObjectPath = null;
1097 String vnfObjectPath = null;
1098 String vfModuleObjectPath = null;
1099 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1101 if (respProps != null) {
1102 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1103 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1104 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1105 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1106 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1107 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1110 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1111 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1112 serviceStatusBuilder.setRpcName(svcOperation);
1114 if (failed(responseObject)) {
1115 responseBuilder.setResponseCode(responseObject.getStatusCode());
1116 responseBuilder.setResponseMessage(responseObject.getMessage());
1117 responseBuilder.setAckFinalIndicator(ackFinal);
1119 ServiceBuilder serviceBuilder = new ServiceBuilder();
1120 serviceBuilder.setServiceInstanceId(siid);
1121 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1123 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1124 } catch (Exception e) {
1125 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1127 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1129 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1130 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1133 return Futures.immediateFuture(rpcResult);
1136 // Got success from SLI
1138 serviceData = serviceDataBuilder.build();
1139 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1142 ServiceBuilder serviceBuilder = new ServiceBuilder();
1143 serviceBuilder.setServiceData(serviceData);
1144 serviceBuilder.setServiceInstanceId(siid);
1145 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1146 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1148 trySaveService(input, serviceBuilder);
1150 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1151 serviceResponseInformationBuilder.setInstanceId(siid);
1152 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1153 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1155 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1156 vnfResponseInformationBuilder.setInstanceId(vnfId);
1157 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1158 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1160 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1161 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1162 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1163 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1165 } catch (Exception e) {
1166 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1167 responseBuilder.setResponseCode("500");
1168 responseBuilder.setResponseMessage(e.getMessage());
1169 responseBuilder.setAckFinalIndicator("Y");
1170 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1172 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1173 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1175 return Futures.immediateFuture(rpcResult);
1179 responseBuilder.setResponseCode(responseObject.getStatusCode());
1180 responseBuilder.setAckFinalIndicator(ackFinal);
1181 trySetResponseMessage(responseBuilder, responseObject);
1182 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1183 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1185 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1186 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1189 return Futures.immediateFuture(rpcResult);
1192 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1193 ResponseObject responseObject) {
1194 if (responseObject.getMessage() != null) {
1195 responseBuilder.setResponseMessage(responseObject.getMessage());
1199 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1200 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1201 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1202 // Only update operational tree on activate or delete
1204 log.info(UPDATING_TREE_INFO_MESSAGE);
1205 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1209 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1210 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1211 if (input.getSdncRequestHeader() != null) {
1212 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1216 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1217 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1218 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1221 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1222 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1223 || input.getVnfInformation().getVnfId().length() == 0;
1226 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1227 return input == null || input.getServiceInformation() == null
1228 || input.getServiceInformation().getServiceInstanceId() == null
1229 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1232 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1233 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1237 public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1238 NetworkTopologyOperationInput input) {
1240 final String svcOperation = "network-topology-operation";
1241 ServiceData serviceData;
1242 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1243 Properties parms = new Properties();
1245 log.info(CALLED_STR, svcOperation);
1246 // create a new response object
1247 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1249 if (hasInvalidServiceId(input)) {
1250 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1251 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1254 String siid = input.getServiceInformation().getServiceInstanceId();
1256 // Get the service-instance service data from MD-SAL
1257 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1258 getServiceData(siid, serviceDataBuilder);
1260 this.trySetSvcRequestId(input, responseBuilder);
1262 ServiceData sd = serviceDataBuilder.build();
1263 if (isInvalidServiceData(sd)) {
1264 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1265 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1268 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1269 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1270 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1272 // Call SLI sync method
1274 ResponseObject responseObject = new ResponseObject("200", "");
1275 String ackFinal = "Y";
1276 String networkId = ERROR_NETWORK_ID;
1277 String serviceObjectPath = null;
1278 String networkObjectPath = null;
1279 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1281 if (respProps != null) {
1282 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1283 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1284 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1285 networkId = respProps.getProperty("networkId");
1286 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1287 networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1290 if (failed(responseObject)) {
1291 responseBuilder.setResponseCode(responseObject.getStatusCode());
1292 responseBuilder.setResponseMessage(responseObject.getMessage());
1293 responseBuilder.setAckFinalIndicator(ackFinal);
1295 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1297 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1298 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1300 return Futures.immediateFuture(rpcResult);
1303 // Got success from SLI
1306 serviceData = serviceDataBuilder.build();
1307 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1310 ServiceBuilder serviceBuilder = new ServiceBuilder();
1311 serviceBuilder.setServiceData(serviceData);
1312 serviceBuilder.setServiceInstanceId(siid);
1313 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1314 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1316 trySaveService(input, serviceBuilder);
1318 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1319 networkResponseInformationBuilder.setInstanceId(networkId);
1320 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1321 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1323 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1324 serviceResponseInformationBuilder.setInstanceId(siid);
1325 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1326 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1328 } catch (IllegalStateException e) {
1329 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1330 responseBuilder.setResponseCode("500");
1331 responseBuilder.setResponseMessage(e.getMessage());
1332 responseBuilder.setAckFinalIndicator("Y");
1333 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1335 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1336 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1338 return Futures.immediateFuture(rpcResult);
1342 responseBuilder.setResponseCode(responseObject.getStatusCode());
1343 responseBuilder.setAckFinalIndicator(ackFinal);
1344 trySetResponseMessage(responseBuilder, responseObject);
1345 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1346 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1348 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1349 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1351 return Futures.immediateFuture(rpcResult);
1354 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1355 ResponseObject responseObject) {
1356 if (responseObject.getMessage() != null) {
1357 responseBuilder.setResponseMessage(responseObject.getMessage());
1361 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1362 NetworkTopologyOperationOutputBuilder responseBuilder) {
1363 if (input.getSdncRequestHeader() != null) {
1364 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1368 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1369 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1370 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1371 // Only update operational tree on Activate
1372 log.info(UPDATING_TREE_INFO_MESSAGE);
1373 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1377 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1378 return input == null || input.getServiceInformation() == null
1379 || input.getServiceInformation().getServiceInstanceId() == null
1380 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1383 private ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1384 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1386 responseBuilder.setResponseCode("404");
1387 responseBuilder.setResponseMessage(responseMessage);
1388 responseBuilder.setAckFinalIndicator("Y");
1390 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1391 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1393 return Futures.immediateFuture(rpcResult);
1396 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1397 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1401 public ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1402 ContrailRouteTopologyOperationInput input) {
1404 final String svcOperation = "contrail-route-topology-operation";
1405 ServiceData serviceData;
1406 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1407 Properties properties = new Properties();
1409 log.info(CALLED_STR, svcOperation);
1410 // create a new response object
1411 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1413 if (hasInvalidServiceId(input)) {
1414 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1415 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1418 String siid = input.getServiceInformation().getServiceInstanceId();
1420 // Get the service-instance service data from MD-SAL
1421 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1422 getServiceData(siid, serviceDataBuilder);
1424 trySetSvcRequestId(input, responseBuilder);
1426 ServiceData sd = serviceDataBuilder.build();
1427 if (isInvalidServiceData(sd)) {
1428 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1429 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1432 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1433 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1434 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1436 // Call SLI sync method
1438 ResponseObject responseObject = new ResponseObject("200", "");
1439 String ackFinal = "Y";
1440 String allottedResourceId = ERROR_NETWORK_ID;
1441 String serviceObjectPath = null;
1442 String contrailRouteObjectPath = null;
1443 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1445 if (respProps != null) {
1446 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1447 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1448 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1449 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1450 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1451 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1454 if (failed(responseObject)) {
1455 responseBuilder.setResponseCode(responseObject.getStatusCode());
1456 responseBuilder.setResponseMessage(responseObject.getMessage());
1457 responseBuilder.setAckFinalIndicator(ackFinal);
1458 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1460 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1461 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1463 return Futures.immediateFuture(rpcResult);
1466 // Got success from SLI
1468 serviceData = serviceDataBuilder.build();
1469 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1472 ServiceBuilder serviceBuilder = new ServiceBuilder();
1473 serviceBuilder.setServiceData(serviceData);
1474 serviceBuilder.setServiceInstanceId(siid);
1475 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1476 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1478 trySaveService(input, serviceBuilder);
1480 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1481 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1482 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1483 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1485 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1486 serviceResponseInformationBuilder.setInstanceId(siid);
1487 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1488 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1490 } catch (IllegalStateException e) {
1491 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1492 responseBuilder.setResponseCode("500");
1493 responseBuilder.setResponseMessage(e.getMessage());
1494 responseBuilder.setAckFinalIndicator("Y");
1495 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1497 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1498 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1500 return Futures.immediateFuture(rpcResult);
1504 responseBuilder.setResponseCode(responseObject.getStatusCode());
1505 responseBuilder.setAckFinalIndicator(ackFinal);
1506 trySetResponseMessage(responseBuilder, responseObject);
1507 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1508 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1510 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1511 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1513 return Futures.immediateFuture(rpcResult);
1516 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1517 ResponseObject responseObject) {
1518 if (responseObject.getMessage() != null) {
1519 responseBuilder.setResponseMessage(responseObject.getMessage());
1523 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1524 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1525 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1526 // Only update operational tree on activate or delete
1527 log.info(UPDATING_TREE_INFO_MESSAGE);
1528 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1532 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1533 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1534 if (input.getSdncRequestHeader() != null) {
1535 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1539 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1540 return input == null || input.getServiceInformation() == null
1541 || input.getServiceInformation().getServiceInstanceId() == null
1542 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1545 private ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
1546 ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1547 responseBuilder.setResponseCode("404");
1548 responseBuilder.setResponseMessage(responseMessage);
1549 responseBuilder.setAckFinalIndicator("Y");
1551 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1552 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1554 return Futures.immediateFuture(rpcResult);
1557 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1558 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1562 public ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1563 SecurityZoneTopologyOperationInput input) {
1565 final String svcOperation = "security-zone-topology-operation";
1566 ServiceData serviceData;
1567 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1568 Properties parms = new Properties();
1570 log.info(CALLED_STR, svcOperation);
1571 // create a new response object
1572 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1574 if (this.hasInvalidServiceId(input)) {
1575 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1576 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1579 String siid = input.getServiceInformation().getServiceInstanceId();
1581 // Get the service-instance service data from MD-SAL
1582 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1583 getServiceData(siid, serviceDataBuilder);
1584 trySetSvcRequestId(input, responseBuilder);
1586 ServiceData sd = serviceDataBuilder.build();
1587 if (isInvalidServiceData(sd)) {
1588 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1589 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1592 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1593 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1594 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1596 // Call SLI sync method
1598 Properties respProps = null;
1600 ResponseObject responseObject = new ResponseObject("200", "");
1601 String ackFinal = "Y";
1602 String allottedResourceId = ERROR_NETWORK_ID;
1603 String serviceObjectPath = null;
1604 String securityZoneObjectPath = null;
1607 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1610 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1611 } catch (Exception e) {
1612 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1613 responseObject.setMessage(e.getMessage());
1614 responseObject.setStatusCode("500");
1617 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1618 responseObject.setStatusCode("503");
1620 } catch (Exception e) {
1621 responseObject.setStatusCode("500");
1622 responseObject.setMessage(e.getMessage());
1623 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1626 if (respProps != null) {
1627 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1628 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1629 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1630 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1631 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1632 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1635 if (failed(responseObject)) {
1636 responseBuilder.setResponseCode(responseObject.getStatusCode());
1637 responseBuilder.setResponseMessage(responseObject.getMessage());
1638 responseBuilder.setAckFinalIndicator(ackFinal);
1639 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1641 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1642 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1644 return Futures.immediateFuture(rpcResult);
1647 // Got success from SLI
1650 serviceData = serviceDataBuilder.build();
1651 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1654 ServiceBuilder serviceBuilder = new ServiceBuilder();
1655 serviceBuilder.setServiceData(serviceData);
1656 serviceBuilder.setServiceInstanceId(siid);
1657 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1658 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1660 trySaveService(input, serviceBuilder);
1662 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1663 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1664 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1665 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1667 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1668 serviceResponseInformationBuilder.setInstanceId(siid);
1669 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1670 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1672 } catch (IllegalStateException e) {
1673 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1674 responseBuilder.setResponseCode("500");
1675 responseBuilder.setResponseMessage(e.getMessage());
1676 responseBuilder.setAckFinalIndicator("Y");
1677 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1679 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1680 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1682 return Futures.immediateFuture(rpcResult);
1686 responseBuilder.setResponseCode(responseObject.getStatusCode());
1687 responseBuilder.setAckFinalIndicator(ackFinal);
1688 trySetResponseMessage(responseBuilder, responseObject);
1689 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1690 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1692 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1693 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1695 return Futures.immediateFuture(rpcResult);
1698 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1699 ResponseObject responseObject) {
1700 if (responseObject.getMessage() != null) {
1701 responseBuilder.setResponseMessage(responseObject.getMessage());
1705 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1706 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1707 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1708 // Only update operational tree on activate or delete
1709 log.info(UPDATING_TREE_INFO_MESSAGE);
1710 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1714 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1715 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1716 if (input.getSdncRequestHeader() != null) {
1717 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1721 private boolean isInvalidServiceData(ServiceData sd) {
1722 return sd == null || sd.getServiceLevelOperStatus() == null;
1725 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1726 return input == null || input.getServiceInformation() == null
1727 || input.getServiceInformation().getServiceInstanceId() == null
1728 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1731 private ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
1732 SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1734 responseBuilder.setResponseCode("404");
1735 responseBuilder.setResponseMessage(responseMessage);
1736 responseBuilder.setAckFinalIndicator("Y");
1738 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1739 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1741 return Futures.immediateFuture(rpcResult);
1744 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1745 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1749 private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
1750 return input == null || input.getServiceInformation() == null
1751 || input.getServiceInformation().getServiceInstanceId() == null
1752 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1755 private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
1756 ResponseObject error) {
1757 if (!error.getMessage().isEmpty()) {
1758 responseBuilder.setResponseMessage(error.getMessage());
1762 private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
1763 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
1764 if (input.getSdncRequestHeader() != null) {
1765 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1769 private ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
1770 buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1772 responseBuilder.setResponseCode("404");
1773 responseBuilder.setResponseMessage(responseMessage);
1774 responseBuilder.setAckFinalIndicator("Y");
1776 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1777 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1778 .withResult(responseBuilder.build())
1781 return Futures.immediateFuture(rpcResult);
1784 private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1785 if (isValidRequest(input) &&
1786 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1787 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1788 // Only update operational tree on activate or delete
1789 log.info(UPDATING_TREE_INFO_MESSAGE);
1790 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1794 private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
1795 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1799 public ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(ConnectionAttachmentTopologyOperationInput input) {
1800 final String svcOperation = "connection-attachment-topology-operation";
1801 Properties parms = new Properties();
1802 log.info(CALLED_STR, svcOperation);
1804 // create a new response object
1805 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
1806 if (hasInvalidServiceId(input)) {
1807 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1808 responseBuilder.setResponseCode("404");
1809 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1810 responseBuilder.setAckFinalIndicator("Y");
1812 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1813 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1814 .withResult(responseBuilder.build())
1817 return Futures.immediateFuture(rpcResult);
1820 ServiceData serviceData;
1821 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1823 String siid = input.getServiceInformation().getServiceInstanceId();
1824 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1826 // Get the service-instance service data from MD-SAL
1827 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1828 getServiceData(siid, serviceDataBuilder);
1830 trySetSvcRequestId(input, responseBuilder);
1832 ServiceData sd = serviceDataBuilder.build();
1833 if (isInvalidServiceData(sd)) {
1834 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1835 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1838 ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(input);
1839 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1841 // Call SLI sync method
1842 // Get SvcLogicService reference
1843 ResponseObject responseObject = new ResponseObject("200", "");
1844 String ackFinal = "Y";
1845 String allottedResourceId = ERROR_NETWORK_ID;
1846 String serviceObjectPath = null;
1847 String connectionAttachmentObjectPath = null;
1849 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1851 if (respProps != null) {
1852 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1853 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1854 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1855 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1856 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1857 connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
1860 if (failed(responseObject)) {
1861 responseBuilder.setResponseCode(responseObject.getStatusCode());
1862 responseBuilder.setResponseMessage(responseObject.getMessage());
1863 responseBuilder.setAckFinalIndicator(ackFinal);
1865 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1867 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1868 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1869 .withResult(responseBuilder.build())
1872 return Futures.immediateFuture(rpcResult);
1875 // Got success from SLI
1878 serviceData = serviceDataBuilder.build();
1879 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1882 ServiceBuilder serviceBuilder = new ServiceBuilder();
1883 serviceBuilder.setServiceData(serviceData);
1884 serviceBuilder.setServiceInstanceId(siid);
1885 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1886 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1888 trySaveService(input, serviceBuilder);
1890 ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
1891 connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
1892 connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
1893 responseBuilder.setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
1895 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1896 serviceResponseInformationBuilder.setInstanceId(siid);
1897 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1898 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1900 } catch (IllegalStateException e) {
1901 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1902 responseBuilder.setResponseCode("500");
1903 responseBuilder.setResponseMessage(e.getMessage());
1904 responseBuilder.setAckFinalIndicator("Y");
1905 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1907 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1908 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1909 .withResult(responseBuilder.build())
1912 return Futures.immediateFuture(rpcResult);
1916 responseBuilder.setResponseCode(responseObject.getStatusCode());
1917 responseBuilder.setAckFinalIndicator(ackFinal);
1918 trySetResponseMessage(responseBuilder, responseObject);
1919 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1920 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1922 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1923 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1924 .withResult(responseBuilder.build())
1927 return Futures.immediateFuture(rpcResult);
1931 public ListenableFuture<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1932 TunnelxconnTopologyOperationInput input) {
1934 final String svcOperation = "tunnelxconn-topology-operation";
1935 Properties parms = new Properties();
1936 log.info(CALLED_STR, svcOperation);
1938 // create a new response object
1939 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1940 if (hasInvalidServiceId(input)) {
1941 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1942 responseBuilder.setResponseCode("404");
1943 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1944 responseBuilder.setAckFinalIndicator("Y");
1946 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1947 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1949 return Futures.immediateFuture(rpcResult);
1951 String siid = input.getServiceInformation().getServiceInstanceId();
1952 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1953 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1954 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1956 // Call SLI sync method
1958 ResponseObject responseObject = new ResponseObject("200", "");
1959 String ackFinal = "Y";
1960 String allottedResourceId = ERROR_NETWORK_ID;
1961 String serviceObjectPath = null;
1962 String tunnelxconnObjectPath = null;
1963 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1965 if (respProps != null) {
1966 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1967 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1968 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1969 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1970 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1971 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1974 if (failed(responseObject)) {
1975 responseBuilder.setResponseCode(responseObject.getStatusCode());
1976 responseBuilder.setResponseMessage(responseObject.getMessage());
1977 responseBuilder.setAckFinalIndicator(ackFinal);
1979 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1981 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1982 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1984 return Futures.immediateFuture(rpcResult);
1987 // Got success from SLI
1989 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1990 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1991 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1992 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1994 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1995 serviceResponseInformationBuilder.setInstanceId(siid);
1996 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1997 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1999 } catch (IllegalStateException e) {
2000 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2001 responseBuilder.setResponseCode("500");
2002 responseBuilder.setResponseMessage(e.getMessage());
2003 responseBuilder.setAckFinalIndicator("Y");
2004 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2006 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2007 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2009 return Futures.immediateFuture(rpcResult);
2013 responseBuilder.setResponseCode(responseObject.getStatusCode());
2014 responseBuilder.setAckFinalIndicator(ackFinal);
2015 trySetResponseMessage(responseBuilder, responseObject);
2016 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2017 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2019 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2020 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2022 return Futures.immediateFuture(rpcResult);
2025 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2026 ResponseObject responseObject) {
2027 if (responseObject.getMessage() != null) {
2028 responseBuilder.setResponseMessage(responseObject.getMessage());
2032 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2033 return input == null || input.getServiceInformation() == null
2034 || input.getServiceInformation().getServiceInstanceId() == null
2035 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2038 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2040 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2043 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2044 } catch (Exception e) {
2045 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2046 responseObject.setMessage(e.getMessage());
2047 responseObject.setStatusCode("500");
2050 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2051 responseObject.setStatusCode("503");
2053 } catch (Exception e) {
2054 responseObject.setMessage(e.getMessage());
2055 responseObject.setStatusCode("500");
2056 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2062 public ListenableFuture<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
2063 final String svcOperation = "brg-topology-operation";
2064 Properties parms = new Properties();
2066 log.info(CALLED_STR, svcOperation);
2067 // create a new response object
2068 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2070 if (this.hasInvalidServiceId(input)) {
2072 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2073 responseBuilder.setResponseCode("404");
2074 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2075 responseBuilder.setAckFinalIndicator("Y");
2077 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2078 .withResult(responseBuilder.build()).build();
2080 return Futures.immediateFuture(rpcResult);
2083 String siid = input.getServiceInformation().getServiceInstanceId();
2085 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2086 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2087 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2089 // Call SLI sync method
2091 ResponseObject responseObject = new ResponseObject("200", "");
2092 String ackFinal = "Y";
2093 String allottedResourceId = ERROR_NETWORK_ID;
2094 String serviceObjectPath = null;
2095 String brgObjectPath = null;
2096 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2098 if (respProps != null) {
2099 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2100 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2101 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2102 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2103 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2104 brgObjectPath = respProps.getProperty("brg-object-path");
2107 if (failed(responseObject)) {
2108 responseBuilder.setResponseCode(responseObject.getStatusCode());
2109 responseBuilder.setResponseMessage(responseObject.getMessage());
2110 responseBuilder.setAckFinalIndicator(ackFinal);
2112 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2113 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2114 .withResult(responseBuilder.build()).build();
2116 return Futures.immediateFuture(rpcResult);
2119 // Got success from SLI
2122 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2123 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2124 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2125 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2127 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2128 serviceResponseInformationBuilder.setInstanceId(siid);
2129 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2130 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2132 } catch (IllegalStateException e) {
2133 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2134 responseBuilder.setResponseCode("500");
2135 responseBuilder.setResponseMessage(e.getMessage());
2136 responseBuilder.setAckFinalIndicator("Y");
2137 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2139 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2140 .withResult(responseBuilder.build()).build();
2142 return Futures.immediateFuture(rpcResult);
2146 responseBuilder.setResponseCode(responseObject.getStatusCode());
2147 responseBuilder.setAckFinalIndicator(ackFinal);
2148 trySetResponseMessage(responseBuilder, responseObject);
2149 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2150 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2152 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2153 .withResult(responseBuilder.build()).build();
2155 return Futures.immediateFuture(rpcResult);
2158 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2159 ResponseObject responseObject) {
2160 if (responseObject.getMessage() != null) {
2161 responseBuilder.setResponseMessage(responseObject.getMessage());
2165 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2166 return input == null || input.getServiceInformation() == null
2167 || input.getServiceInformation().getServiceInstanceId() == null
2168 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2171 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2172 if (respProps != null) {
2173 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2174 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2175 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2181 public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2182 PreloadNetworkTopologyOperationInput input) {
2184 final String svcOperation = "preload-network-topology-operation";
2185 PreloadData preloadData;
2186 Properties properties = new Properties();
2188 log.info(CALLED_STR, svcOperation);
2189 // create a new response object
2190 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2192 if (hasInvalidPreloadNetwork(input)) {
2193 log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2194 responseBuilder.setResponseCode("403");
2195 responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2196 responseBuilder.setAckFinalIndicator("Y");
2198 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2199 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2201 return Futures.immediateFuture(rpcResult);
2204 // Grab the preload ID from the input buffer
2205 String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2207 String preloadType = "network";
2209 trySetSvcRequestId(input, responseBuilder);
2211 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2212 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2214 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2215 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2218 // setup a preload-data object builder
2219 // ACTION preload-network-topology-operation
2221 // uses sdnc-request-header;
2222 // uses request-information;
2223 // uses preload-network-topology-information;
2225 // uses preload-topology-response-body;
2227 // container preload-data
2228 // uses preload-network-topology-information;
2229 // uses preload-oper-status;
2231 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2232 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2234 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2235 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2236 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2238 // Call SLI sync method
2239 ResponseObject responseObject = new ResponseObject("200", "");
2240 String ackFinal = "Y";
2241 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2243 if (respProps != null) {
2244 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2245 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2246 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2249 if (failed(responseObject)) {
2250 responseBuilder.setResponseCode(responseObject.getStatusCode());
2251 responseBuilder.setResponseMessage(responseObject.getMessage());
2252 responseBuilder.setAckFinalIndicator(ackFinal);
2253 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2254 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2255 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2256 return Futures.immediateFuture(rpcResult);
2259 // Got success from SLI
2261 preloadData = preloadDataBuilder.build();
2262 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2264 // preload-list object
2265 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2266 preloadListBuilder.setPreloadId(preloadId);
2267 preloadListBuilder.setPreloadType(preloadType);
2268 preloadListBuilder.setPreloadData(preloadData);
2270 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2271 log.info(UPDATING_TREE_INFO_MESSAGE);
2272 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2274 tryDeletePreload(input, preloadListBuilder);
2275 } catch (Exception e) {
2276 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2277 responseBuilder.setResponseCode("500");
2278 responseBuilder.setResponseMessage(e.getMessage());
2279 responseBuilder.setAckFinalIndicator("Y");
2280 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2281 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2282 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2283 return Futures.immediateFuture(rpcResult);
2287 responseBuilder.setResponseCode(responseObject.getStatusCode());
2288 responseBuilder.setAckFinalIndicator(ackFinal);
2289 trySetResponseMessage(responseBuilder, responseObject);
2290 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2291 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2293 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2294 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2295 return Futures.immediateFuture(rpcResult);
2298 private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2299 return input == null || input.getPreloadNetworkTopologyInformation() == null
2300 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2303 private boolean hasInvalidPreloadId(String preloadId) {
2304 return preloadId == null || preloadId.length() == 0;
2307 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2308 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2309 if (input.getSdncRequestHeader() != null) {
2310 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2314 private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2315 ResponseObject responseObject) {
2317 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2319 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2320 } catch (Exception e) {
2321 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2322 responseObject.setMessage(e.getMessage());
2323 responseObject.setStatusCode("500");
2326 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2327 responseObject.setStatusCode("503");
2329 } catch (Exception e) {
2330 responseObject.setMessage(e.getMessage());
2331 responseObject.setStatusCode("500");
2332 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2338 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2339 ResponseObject responseObject) {
2340 if (responseObject.getMessage() != null) {
2341 if (!responseObject.getMessage().isEmpty()) {
2342 responseBuilder.setResponseMessage(responseObject.getMessage());
2347 private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2348 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2349 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2350 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2351 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2356 public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2357 PreloadVfModuleTopologyOperationInput input) {
2359 final String svcOperation = "preload-vf-module-topology-operation";
2360 PreloadData preloadData;
2361 Properties properties = new Properties();
2363 log.info(CALLED_STR, svcOperation);
2364 // create a new response object
2365 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2367 if (hasInvalidPreloadVfModule(input)) {
2369 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2371 responseBuilder.setResponseCode("403");
2372 responseBuilder.setResponseMessage(
2373 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2374 responseBuilder.setAckFinalIndicator("Y");
2376 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2377 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2379 return Futures.immediateFuture(rpcResult);
2382 // Grab the preload ID from the input buffer
2383 String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2384 .getVfModuleTopologyIdentifier().getVfModuleName();
2385 String preloadType = "vf-module";
2387 trySetSvcRequestId(input, responseBuilder);
2389 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2390 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2392 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2393 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2396 // setup a preload-data object builder
2397 // ACTION preload-vf-module-topology-operation
2399 // uses sdnc-request-header;
2400 // uses request-information;
2401 // uses preload-vnf-topology-information;
2403 // uses preload-topology-response-body;
2405 // container preload-data
2406 // uses preload-vf-module-topology-information;
2407 // uses preload-oper-status;
2409 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2410 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2412 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2413 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2414 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2416 // Call SLI sync method
2417 ResponseObject responseObject = new ResponseObject("200", "");
2418 String ackFinal = "Y";
2419 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2421 if (respProps != null) {
2422 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2423 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2424 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2427 if (failed(responseObject)) {
2428 responseBuilder.setResponseCode(responseObject.getStatusCode());
2429 responseBuilder.setResponseMessage(responseObject.getMessage());
2430 responseBuilder.setAckFinalIndicator(ackFinal);
2431 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2432 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2433 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2434 return Futures.immediateFuture(rpcResult);
2437 // Got success from SLI
2439 preloadData = preloadDataBuilder.build();
2440 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2442 // preload-list object
2443 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2444 preloadListBuilder.setPreloadId(preloadId);
2445 preloadListBuilder.setPreloadType(preloadType);
2446 preloadListBuilder.setPreloadData(preloadData);
2448 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2449 log.info(UPDATING_TREE_INFO_MESSAGE);
2450 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2452 tryDeletePreload(input, preloadListBuilder);
2454 } catch (Exception e) {
2455 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2456 responseBuilder.setResponseCode("500");
2457 responseBuilder.setResponseMessage(e.getMessage());
2458 responseBuilder.setAckFinalIndicator("Y");
2459 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2460 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2461 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2462 return Futures.immediateFuture(rpcResult);
2466 responseBuilder.setResponseCode(responseObject.getStatusCode());
2467 responseBuilder.setAckFinalIndicator(ackFinal);
2468 trySetResponseMessage(responseBuilder, responseObject);
2469 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2470 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2472 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2473 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2474 return Futures.immediateFuture(rpcResult);
2477 private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
2478 return input == null || input.getPreloadVfModuleTopologyInformation() == null
2479 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
2480 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2481 .getVfModuleTopologyIdentifier() == null
2482 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
2483 .getVfModuleName() == null;
2486 private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
2487 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
2488 if (input.getSdncRequestHeader() != null) {
2489 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2493 private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
2494 ResponseObject responseObject) {
2495 if (responseObject.getMessage() != null) {
2496 if (!responseObject.getMessage().isEmpty()) {
2497 responseBuilder.setResponseMessage(responseObject.getMessage());
2502 private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2503 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2504 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2505 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2506 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2511 public ListenableFuture<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
2512 GenericConfigurationTopologyOperationInput input) {
2514 final String svcOperation = "generic-configuration-topology-operation";
2515 ServiceData serviceData;
2516 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2517 Properties parms = new Properties();
2519 log.info(CALLED_STR, svcOperation);
2520 // create a new response object
2521 GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
2523 if (hasInvalidService(input)) {
2524 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2525 responseBuilder.setResponseCode("404");
2526 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2527 responseBuilder.setAckFinalIndicator("Y");
2529 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2530 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2533 return Futures.immediateFuture(rpcResult);
2536 // Grab the service instance ID from the input buffer
2537 String siid = input.getServiceInformation().getServiceInstanceId();
2539 trySetSvcRequestId(input, responseBuilder);
2541 if (hasInvalidConfigurationIdOrType(input)) {
2542 log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
2543 responseBuilder.setResponseCode("404");
2544 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
2545 responseBuilder.setAckFinalIndicator("Y");
2546 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2547 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2549 return Futures.immediateFuture(rpcResult);
2552 // Grab the configuration ID from the input buffer
2553 String configId = input.getConfigurationInformation().getConfigurationId();
2555 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2556 getServiceData(siid, serviceDataBuilder);
2558 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2559 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2561 // Set the serviceStatus based on input
2562 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2563 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2565 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2566 GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
2568 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2570 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2571 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2573 // Call SLI sync method
2575 ResponseObject responseObject = new ResponseObject("200", "");
2576 String ackFinal = "Y";
2577 String serviceObjectPath = "";
2578 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2580 if (respProps != null) {
2581 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2582 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2583 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2584 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2587 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2588 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2589 serviceStatusBuilder.setRpcName(svcOperation);
2591 if (failed(responseObject)) {
2592 responseBuilder.setResponseCode(responseObject.getStatusCode());
2593 responseBuilder.setResponseMessage(responseObject.getMessage());
2594 responseBuilder.setAckFinalIndicator(ackFinal);
2596 ServiceBuilder serviceBuilder = new ServiceBuilder();
2597 serviceBuilder.setServiceInstanceId(siid);
2598 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2600 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2601 } catch (Exception e) {
2602 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2604 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2606 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2607 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2610 return Futures.immediateFuture(rpcResult);
2613 // Got success from SLI
2615 serviceData = serviceDataBuilder.build();
2618 ServiceBuilder serviceBuilder = new ServiceBuilder();
2619 serviceBuilder.setServiceData(serviceData);
2620 serviceBuilder.setServiceInstanceId(siid);
2621 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2622 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2624 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2625 serviceResponseInformationBuilder.setInstanceId(siid);
2626 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2627 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2628 GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
2629 gcResponseInformationBuilder.setInstanceId(configId);
2630 responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
2632 } catch (Exception e) {
2633 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2634 responseBuilder.setResponseCode("500");
2635 responseBuilder.setResponseMessage(e.getMessage());
2636 responseBuilder.setAckFinalIndicator("Y");
2637 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2638 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2641 return Futures.immediateFuture(rpcResult);
2645 responseBuilder.setResponseCode(responseObject.getStatusCode());
2646 responseBuilder.setAckFinalIndicator(ackFinal);
2647 trySetResponseMessage(responseBuilder, responseObject);
2648 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2649 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2651 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2652 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2654 return Futures.immediateFuture(rpcResult);
2657 private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
2658 return input == null || input.getServiceInformation() == null
2659 || input.getServiceInformation().getServiceInstanceId() == null
2660 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2663 private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
2664 GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
2665 if (input.getSdncRequestHeader() != null) {
2666 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2670 private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
2671 return input.getConfigurationInformation() == null
2672 || input.getConfigurationInformation().getConfigurationId() == null
2673 || input.getConfigurationInformation().getConfigurationType() == null;
2676 private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
2677 ResponseObject responseObject) {
2678 if (responseObject.getMessage() != null) {
2679 if (!responseObject.getMessage().isEmpty()) {
2680 responseBuilder.setResponseMessage(responseObject.getMessage());
2686 public ListenableFuture<RpcResult<GenericConfigurationNotificationOutput>> genericConfigurationNotification(GenericConfigurationNotificationInput input) {
2688 final String svcOperation = "generic-configuration-notification";
2689 ServiceData serviceData;
2690 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2691 Properties parms = new Properties();
2693 log.info(CALLED_STR, svcOperation);
2695 // Grab the service instance ID from the input buffer
2696 String siid = input.getServiceInformation().getServiceInstanceId();
2698 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2699 getServiceData(siid, serviceDataBuilder);
2701 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2702 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2704 // Set the serviceStatus based on input
2705 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2706 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2708 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2709 GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
2711 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2713 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2714 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2716 // Call SLI sync method
2718 ResponseObject responseObject = new ResponseObject("200", "");
2719 String ackFinal = "Y";
2720 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2722 if (respProps != null) {
2723 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2724 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2725 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2728 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2729 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2730 serviceStatusBuilder.setRpcName(svcOperation);
2732 if (failed(responseObject)) {
2733 ServiceBuilder serviceBuilder = new ServiceBuilder();
2734 serviceBuilder.setServiceInstanceId(siid);
2735 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2737 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2738 } catch (Exception e) {
2739 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2745 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(true).build();
2747 return Futures.immediateFuture(rpcResult);
2750 // Got success from SLI
2752 serviceData = serviceDataBuilder.build();
2755 ServiceBuilder serviceBuilder = new ServiceBuilder();
2756 serviceBuilder.setServiceData(serviceData);
2757 serviceBuilder.setServiceInstanceId(siid);
2758 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2759 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2761 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2762 serviceResponseInformationBuilder.setInstanceId(siid);
2764 } catch (Exception e) {
2765 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2766 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(true).build();
2768 return Futures.immediateFuture(rpcResult);
2772 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2774 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(true).build();
2776 return Futures.immediateFuture(rpcResult);
2780 public ListenableFuture<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
2781 GetpathsegmentTopologyOperationInput input) {
2783 final String svcOperation = "getpathsegment-topology-operation";
2784 ServiceData serviceData;
2785 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2786 Properties parms = new Properties();
2788 log.info(CALLED_STR, svcOperation);
2789 // create a new response object
2790 GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
2792 if (hasInvalidService(input)) {
2793 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2794 responseBuilder.setResponseCode("404");
2795 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2796 responseBuilder.setAckFinalIndicator("Y");
2798 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2799 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2801 return Futures.immediateFuture(rpcResult);
2804 // Grab the service instance ID from the input buffer
2805 String siid = input.getServiceInformation().getServiceInstanceId();
2807 trySetSvcRequestId(input, responseBuilder);
2809 if (hasInvalidOnapModelInformation(input)) {
2810 log.debug("exiting {} because no model-uuid provided", svcOperation);
2811 responseBuilder.setResponseCode("404");
2812 responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
2813 responseBuilder.setAckFinalIndicator("Y");
2814 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2815 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2816 return Futures.immediateFuture(rpcResult);
2819 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2820 getServiceData(siid, serviceDataBuilder);
2822 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2823 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2825 // Set the serviceStatus based on input
2826 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2827 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2829 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2830 GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
2832 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2834 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2835 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2837 // Call SLI sync method
2839 ResponseObject responseObject = new ResponseObject("200", "");
2840 String ackFinal = "Y";
2841 String serviceObjectPath = null;
2842 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2844 if (respProps != null) {
2845 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2846 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2847 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2848 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2851 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2852 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2853 serviceStatusBuilder.setRpcName(svcOperation);
2855 if (failed(responseObject)) {
2856 responseBuilder.setResponseCode(responseObject.getStatusCode());
2857 responseBuilder.setResponseMessage(responseObject.getMessage());
2858 responseBuilder.setAckFinalIndicator(ackFinal);
2860 ServiceBuilder serviceBuilder = new ServiceBuilder();
2861 serviceBuilder.setServiceInstanceId(siid);
2862 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2864 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2865 } catch (Exception e) {
2866 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2868 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2870 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2871 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2873 return Futures.immediateFuture(rpcResult);
2876 // Got success from SLI
2878 serviceData = serviceDataBuilder.build();
2879 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2882 ServiceBuilder serviceBuilder = new ServiceBuilder();
2883 serviceBuilder.setServiceData(serviceData);
2884 serviceBuilder.setServiceInstanceId(siid);
2885 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2886 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2888 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2889 serviceResponseInformationBuilder.setInstanceId(siid);
2890 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2891 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2893 } catch (Exception e) {
2894 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2895 responseBuilder.setResponseCode("500");
2896 responseBuilder.setResponseMessage(e.getMessage());
2897 responseBuilder.setAckFinalIndicator("Y");
2898 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2899 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2901 return Futures.immediateFuture(rpcResult);
2905 responseBuilder.setResponseCode(responseObject.getStatusCode());
2906 responseBuilder.setAckFinalIndicator(ackFinal);
2907 trySetResponseMessage(responseBuilder, responseObject);
2908 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2909 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2911 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2912 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2914 return Futures.immediateFuture(rpcResult);
2917 private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
2918 return input == null || input.getServiceInformation() == null
2919 || input.getServiceInformation().getServiceInstanceId() == null
2920 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2923 private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
2924 GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
2925 if (input.getSdncRequestHeader() != null) {
2926 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2930 private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
2931 return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
2932 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
2935 private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
2936 ResponseObject responseObject) {
2937 if (responseObject.getMessage() != null) {
2938 if (!responseObject.getMessage().isEmpty()) {
2939 responseBuilder.setResponseMessage(responseObject.getMessage());
2945 public ListenableFuture<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
2946 PolicyUpdateNotifyOperationInput input) {
2948 final String svcOperation = "policy-update-notify-operation";
2949 Properties parms = new Properties();
2951 log.info(CALLED_STR, svcOperation);
2953 // create a new response object
2954 PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
2956 // Make sure we have a valid input
2957 if (hasInvalidInput(input)) {
2958 log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
2959 responseBuilder.setErrorCode("404");
2960 responseBuilder.setErrorMsg("Invalid input, missing input data");
2961 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2962 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2963 return Futures.immediateFuture(rpcResult);
2966 log.info("Adding INPUT data for {} input: {}", svcOperation, input);
2967 PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
2968 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2970 // Call SLI sync method
2971 ResponseObject responseObject = new ResponseObject("200", "");
2972 String ackFinal = "Y";
2973 String serviceObjectPath = null;
2974 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2976 if (respProps != null) {
2977 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2978 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2979 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2980 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2983 if (failed(responseObject)) {
2984 responseBuilder.setErrorCode(responseObject.getStatusCode());
2985 responseBuilder.setErrorMsg(responseObject.getMessage());
2986 log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
2988 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2989 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2991 return Futures.immediateFuture(rpcResult);
2994 // Got success from SLI
2995 responseBuilder.setErrorCode(responseObject.getStatusCode());
2996 if (responseObject.getMessage() != null) {
2997 responseBuilder.setErrorMsg(responseObject.getMessage());
2999 log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
3000 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3001 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3003 return Futures.immediateFuture(rpcResult);
3006 private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
3007 return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3011 public ListenableFuture<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3012 final PortMirrorTopologyOperationInput input) {
3014 final String svcOperation = "port-mirror-topology-operation";
3015 ServiceData serviceData = null;
3016 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3017 Properties properties = new Properties();
3019 log.info(CALLED_STR, svcOperation);
3021 // create a new response object
3022 PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3024 if (hasInvalidService(input)) {
3025 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3026 responseBuilder.setResponseCode("404");
3027 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3028 responseBuilder.setAckFinalIndicator("Y");
3029 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3030 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3032 return Futures.immediateFuture(rpcResult);
3035 if (hasInvalidConfigurationId(input)) {
3036 log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3037 responseBuilder.setResponseCode("404");
3038 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3039 responseBuilder.setAckFinalIndicator("Y");
3040 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3041 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3042 return Futures.immediateFuture(rpcResult);
3045 // Grab the service instance ID from the input buffer
3046 String siid = input.getServiceInformation().getServiceInstanceId();
3048 trySetSvcRequestId(input, responseBuilder);
3050 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3051 getServiceData(siid, serviceDataBuilder);
3053 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3054 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3056 // Set the serviceStatus based on input
3057 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3058 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3060 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3061 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3062 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3064 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3065 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3067 // Call SLI sync method
3068 ResponseObject responseObject = new ResponseObject("200", "");
3069 String ackFinal = "Y";
3070 String serviceObjectPath = null;
3071 String portMirrorObjectPath = null;
3072 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3074 if (respProps != null) {
3075 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3076 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3077 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3078 serviceObjectPath = respProps.getProperty("service-object-path");
3079 portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3082 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3083 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3084 serviceStatusBuilder.setRpcName(svcOperation);
3086 if (failed(responseObject)) {
3087 responseBuilder.setResponseCode(responseObject.getStatusCode());
3088 responseBuilder.setResponseMessage(responseObject.getMessage());
3089 responseBuilder.setAckFinalIndicator(ackFinal);
3091 ServiceBuilder serviceBuilder = new ServiceBuilder();
3092 serviceBuilder.setServiceInstanceId(siid);
3093 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3095 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3096 } catch (Exception e) {
3097 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3099 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3101 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3102 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3105 return Futures.immediateFuture(rpcResult);
3108 // Got success from SLI
3110 serviceData = serviceDataBuilder.build();
3111 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3114 ServiceBuilder serviceBuilder = new ServiceBuilder();
3115 serviceBuilder.setServiceData(serviceData);
3116 serviceBuilder.setServiceInstanceId(siid);
3117 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3118 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3120 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3121 // Only update operational tree on activate or delete
3122 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3123 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3124 log.info(UPDATING_TREE_INFO_MESSAGE);
3125 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3129 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3130 serviceResponseInformationBuilder.setInstanceId(siid);
3131 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3132 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3133 PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3134 portMirrorResponseInformationBuilder
3135 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3136 portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3137 responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3139 } catch (Exception e) {
3140 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3141 responseBuilder.setResponseCode("500");
3142 responseBuilder.setResponseMessage(e.getMessage());
3143 responseBuilder.setAckFinalIndicator("Y");
3144 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3145 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3146 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3147 return Futures.immediateFuture(rpcResult);
3151 responseBuilder.setResponseCode(responseObject.getStatusCode());
3152 responseBuilder.setAckFinalIndicator(ackFinal);
3153 trySetResponseMessage(responseBuilder, responseObject);
3154 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3155 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3157 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3158 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3160 if (ackFinal.equals("N")) {
3161 // Spawn background thread to invoke the Async DG
3162 Runnable backgroundThread = new Runnable() {
3164 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3165 processAsyncPortMirrorTopologyOperation(input);
3168 new Thread(backgroundThread).start();
3172 return Futures.immediateFuture(rpcResult);
3175 private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3176 return input == null || input.getServiceInformation() == null
3177 || input.getServiceInformation().getServiceInstanceId() == null
3178 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3181 private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3182 return input.getConfigurationInformation() == null
3183 || input.getConfigurationInformation().getConfigurationId() == null
3184 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3187 private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3188 PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3189 if (input.getSdncRequestHeader() != null) {
3190 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3194 private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3195 ResponseObject responseObject) {
3196 if (responseObject.getMessage() != null) {
3197 if (!responseObject.getMessage().isEmpty()) {
3198 responseBuilder.setResponseMessage(responseObject.getMessage());
3203 public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3204 log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3206 final String svcOperation = "port-mirror-topology-operation-async";
3207 ServiceData serviceData = null;
3208 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3209 Properties parms = new Properties();
3211 log.info(CALLED_STR, svcOperation);
3213 // Grab the service instance ID from the input buffer
3214 String siid = input.getServiceInformation().getServiceInstanceId();
3216 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3217 getServiceData(siid, serviceDataBuilder);
3219 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3220 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3222 // Set the serviceStatus based on input
3223 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3224 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3226 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3227 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3228 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3230 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3231 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3233 // Call SLI sync method
3234 ResponseObject responseObject = new ResponseObject("200", "");
3235 String ackFinal = "Y";
3236 String serviceObjectPath = null;
3237 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3239 if (respProps != null) {
3240 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3241 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3242 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3245 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3246 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3247 serviceStatusBuilder.setRpcName(svcOperation);
3249 if (failed(responseObject)) {
3250 ServiceBuilder serviceBuilder = new ServiceBuilder();
3251 serviceBuilder.setServiceInstanceId(siid);
3252 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3254 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3255 } catch (Exception e) {
3256 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3263 // Got success from SLI
3265 serviceData = serviceDataBuilder.build();
3266 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3269 ServiceBuilder serviceBuilder = new ServiceBuilder();
3270 serviceBuilder.setServiceData(serviceData);
3271 serviceBuilder.setServiceInstanceId(siid);
3272 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3273 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3275 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3276 // Only update operational tree on activate or delete
3277 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3278 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3279 log.info(UPDATING_TREE_INFO_MESSAGE);
3280 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3284 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3285 serviceResponseInformationBuilder.setInstanceId(siid);
3286 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3288 } catch (Exception e) {
3289 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3294 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3300 public ListenableFuture<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(VnfGetResourceRequestInput input) {
3302 final String svcOperation = "vnf-get-resource-request";
3303 ServiceData serviceData;
3304 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3305 Properties parms = new Properties();
3307 log.info(CALLED_STR, svcOperation);
3308 // create a new response object
3309 VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3311 if (hasInvalidService(input)) {
3312 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3313 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3314 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3316 return Futures.immediateFuture(rpcResult);
3319 // Grab the service instance ID from the input buffer
3320 String siid = input.getServiceInformation().getServiceInstanceId();
3322 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3323 getServiceData(siid, serviceDataBuilder);
3325 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3326 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3328 // Set the serviceStatus based on input
3329 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3330 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3332 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3333 VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3334 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3336 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3337 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3339 // Call SLI sync method
3341 ResponseObject responseObject = new ResponseObject("200", "");
3342 String ackFinal = "Y";
3343 String serviceObjectPath = null;
3344 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3346 if (respProps != null) {
3347 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3348 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3349 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3350 serviceObjectPath = respProps.getProperty("service-object-path");
3353 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3354 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3355 serviceStatusBuilder.setRpcName(svcOperation);
3357 if (failed(responseObject)) {
3358 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3359 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3360 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3362 return Futures.immediateFuture(rpcResult);
3365 // Got success from SLI
3366 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3368 if (respProps != null) {
3369 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3372 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3373 .withResult(responseBuilder.build()).build();
3376 return Futures.immediateFuture(rpcResult);
3379 private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3380 return input == null || input.getServiceInformation() == null
3381 || input.getServiceInformation().getServiceInstanceId() == null
3382 || input.getServiceInformation().getServiceInstanceId().length() == 0;