1 package org.onap.sdnc.northbound;
3 import com.google.common.base.Optional;
4 import com.google.common.util.concurrent.CheckedFuture;
5 import com.google.common.util.concurrent.Futures;
6 import java.text.DateFormat;
7 import java.text.SimpleDateFormat;
9 import java.util.Properties;
10 import java.util.TimeZone;
11 import java.util.concurrent.ExecutionException;
12 import java.util.concurrent.ExecutorService;
13 import java.util.concurrent.Executors;
14 import java.util.concurrent.Future;
16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
17 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
18 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
19 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
21 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
22 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
23 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
24 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInput;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInputBuilder;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutput;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutputBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationInput;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationInputBuilder;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationInput;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationInputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationOutput;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationOutputBuilder;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationInput;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationInputBuilder;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationOutput;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationOutputBuilder;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationInput;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationInputBuilder;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationOutput;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationOutputBuilder;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationInput;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationInputBuilder;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationOutput;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationOutputBuilder;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadInformation;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadInformationBuilder;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationInput;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationInputBuilder;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationOutput;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationOutputBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestInput;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestInputBuilder;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestOutput;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestOutputBuilder;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.connection.attachment.response.information.ConnectionAttachmentResponseInformationBuilder;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.gc.response.information.GcResponseInformationBuilder;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.port.mirror.response.information.PortMirrorResponseInformationBuilder;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadList;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListBuilder;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListKey;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vf.module.response.information.VfModuleResponseInformationBuilder;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vnf.response.information.VnfResponseInformationBuilder;
123 import org.opendaylight.yangtools.yang.binding.DataObject;
124 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
125 import org.opendaylight.yangtools.yang.common.RpcResult;
126 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
127 import org.slf4j.Logger;
128 import org.slf4j.LoggerFactory;
131 * Defines a base implementation for your provider. This class extends from a
132 * helper class which provides storage for the most commonly used components of
133 * the MD-SAL. Additionally the base class provides some basic logging and
134 * initialization / clean up methods.
136 * To use this, copy and paste (overwrite) the following method into the
137 * TestApplicationProviderModule class which is auto generated under
138 * src/main/java in this project (created only once during first compilation):
143 * public java.lang.AutoCloseable createInstance() {
145 * // final GENERIC-RESOURCE-APIProvider provider = new
146 * // GENERIC-RESOURCE-APIProvider();
147 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
148 * provider.setDataBroker(getDataBrokerDependency());
149 * provider.setNotificationService(getNotificationServiceDependency());
150 * provider.setRpcRegistry(getRpcRegistryDependency());
151 * provider.initialize();
152 * return new AutoCloseable() {
155 * public void close() throws Exception {
156 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
157 * // BROKER/NOTIFICATION
158 * // SERVIE/RPC REGISTRY
167 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
169 protected static final String APP_NAME = "generic-resource-api";
170 private static final String CALLED_STR = "{} called.";
171 private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
172 protected static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
173 private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
174 private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
175 private static final String OPERATIONAL_DATA_PARAM = "operational-data";
176 protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
177 private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
178 private static final String ERROR_CODE_PARAM = "error-code";
179 private static final String ERROR_MESSAGE_PARAM = "error-message";
180 private static final String ACK_FINAL_PARAM = "ack-final";
181 private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
182 private static final String NETWORK_OBJECT_PATH_PARAM = "network-object-path";
183 private static final String VNF_OBJECT_PATH_PARAM = "vnf-object-path";
184 private static final String VF_MODULE_OBJECT_PATH_PARAM = "vf-module-object-path";
185 private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
186 private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
187 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
188 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
189 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
190 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
191 private static final String NON_NULL_PARAM = "non-null";
192 private static final String NULL_PARAM = "null";
193 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
194 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
195 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
196 protected static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
197 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
198 private static final String ERROR_NETWORK_ID = "error";
199 private static final String BACKGROUND_THREAD_STARTED_MESSAGE = "Start background thread";
200 private static final String BACKGROUND_THREAD_INFO = "Background thread: input conf_id is {}";
202 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
203 private final ExecutorService executor;
204 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
206 protected DataBroker dataBroker;
207 protected NotificationPublishService notificationService;
208 protected RpcProviderRegistry rpcRegistry;
209 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
211 public GenericResourceApiProvider(DataBroker dataBroker, NotificationPublishService notificationPublishService,
212 RpcProviderRegistry rpcProviderRegistry, GenericResourceApiSvcLogicServiceClient client) {
213 log.info("Creating provider for {}", APP_NAME);
214 executor = Executors.newFixedThreadPool(1);
215 setDataBroker(dataBroker);
216 setNotificationService(notificationPublishService);
217 setRpcRegistry(rpcProviderRegistry);
218 svcLogicClient = client;
223 public void initialize() {
224 log.info("Initializing provider for {}", APP_NAME);
225 // Create the top level containers
228 GenericResourceApiUtil.loadProperties();
229 } catch (Exception e) {
230 log.error("Caught Exception while trying to load properties file", e);
233 log.info("Initialization complete for {}", APP_NAME);
236 protected void initializeChild() {
237 // Override if you have custom initialization intelligence
241 public void close() throws Exception {
242 log.info("Closing provider for {}", APP_NAME);
244 rpcRegistration.close();
245 log.info("Successfully closed provider for {}", APP_NAME);
248 private static class Iso8601Util {
250 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
251 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
253 private Iso8601Util() {
257 dateFormat.setTimeZone(timeZone);
260 private static String now() {
261 return dateFormat.format(new Date());
265 public void setDataBroker(DataBroker dataBroker) {
266 this.dataBroker = dataBroker;
267 if (log.isDebugEnabled()) {
268 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
272 public void setNotificationService(NotificationPublishService notificationService) {
273 this.notificationService = notificationService;
274 if (log.isDebugEnabled()) {
275 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
279 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
280 this.rpcRegistry = rpcRegistry;
281 if (log.isDebugEnabled()) {
282 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
286 private void createContainers() {
288 final WriteTransaction t = dataBroker.newReadWriteTransaction();
290 // Create the service-instance container
291 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
292 new ServicesBuilder().build());
293 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
294 new ServicesBuilder().build());
296 // Create the PreloadInformation container
297 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadInformation.class),
298 new PreloadInformationBuilder().build());
299 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadInformation.class),
300 new PreloadInformationBuilder().build());
303 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
305 log.info("Create containers succeeded!");
307 } catch (InterruptedException | ExecutionException e) {
308 log.error("Create containers failed: ", e);
312 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
314 serviceStatusBuilder.setResponseCode(errorCode);
315 serviceStatusBuilder.setResponseMessage(errorMessage);
316 serviceStatusBuilder.setFinalIndicator(ackFinal);
317 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
320 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
321 if (requestInformation != null && requestInformation.getRequestAction() != null) {
322 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
326 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
327 if (requestHeader != null && requestHeader.getSvcAction() != null) {
328 switch (requestHeader.getSvcAction()) {
330 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
333 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
336 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
339 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
342 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
345 serviceStatusBuilder.setRpcAction(RpcAction.Create);
348 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
354 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
356 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
359 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
360 // See if any data exists yet for this siid, if so grab it.
361 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier.builder(Services.class)
362 .child(Service.class, new ServiceKey(siid)).build();
364 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
365 Optional<Service> data = Optional.absent();
367 data = readTx.read(type, serviceInstanceIdentifier).get();
368 } catch (InterruptedException | ExecutionException e) {
369 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
372 if (data != null && data.isPresent()) {
373 ServiceData serviceData = data.get().getServiceData();
374 if (serviceData != null) {
375 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
376 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
377 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
378 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
379 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
380 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
381 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
382 serviceDataBuilder.setNetworks(serviceData.getNetworks());
383 serviceDataBuilder.setVnfs(serviceData.getVnfs());
384 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
385 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
386 serviceDataBuilder.setNetworkInstanceGroups(serviceData.getNetworkInstanceGroups());
387 serviceDataBuilder.setVnfcInstanceGroups(serviceData.getVnfcInstanceGroups());
388 serviceDataBuilder.setForwardingPaths(serviceData.getForwardingPaths());
389 serviceDataBuilder.setProvidedConfigurations(serviceData.getProvidedConfigurations());
390 // service-instance-id needs to be set
392 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
395 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
399 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
400 // Each entry will be identifiable by a unique key, we have to create that
402 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
403 .child(Service.class, entry.getKey()).build();
405 trySaveEntry(entry, merge, storeType, path);
408 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
409 InstanceIdentifier<T> path) {
413 save(entry, merge, storeType, path);
415 } catch (OptimisticLockFailedException e) {
417 log.debug("Got OptimisticLockFailedException on last try - failing ");
418 throw new IllegalStateException(e);
420 log.debug("Got OptimisticLockFailedException - trying again ");
421 } catch (TransactionCommitFailedException ex) {
422 log.debug("Update DataStore failed");
423 throw new IllegalStateException(ex);
428 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
429 InstanceIdentifier<T> path) throws TransactionCommitFailedException {
430 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
432 tx.merge(storeType, path, entry);
434 tx.put(storeType, path, entry);
436 tx.submit().checkedGet();
437 log.debug("Update DataStore succeeded");
440 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
441 // Each entry will be identifiable by a unique key, we have to create
443 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
444 .child(Service.class, entry.getKey()).build();
446 tryDeleteEntry(storeType, path);
449 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
453 delete(storeType, path);
455 } catch (OptimisticLockFailedException e) {
457 log.debug("Got OptimisticLockFailedException on last try - failing ");
458 throw new IllegalStateException(e);
460 log.debug("Got OptimisticLockFailedException - trying again ");
461 } catch (TransactionCommitFailedException ex) {
462 log.debug("Update DataStore failed");
463 throw new IllegalStateException(ex);
468 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
469 throws TransactionCommitFailedException {
470 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
471 tx.delete(storeType, path);
472 tx.submit().checkedGet();
473 log.debug("DataStore delete succeeded");
476 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
478 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
481 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
482 LogicalDatastoreType type) {
483 // See if any data exists yet for this name/type, if so grab it.
484 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier
485 .<PreloadInformation>builder(PreloadInformation.class)
486 .child(PreloadList.class, new PreloadListKey(preloadName, preloadType)).build();
487 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
488 Optional<PreloadList> data = null;
490 data = (Optional<PreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
491 } catch (InterruptedException | ExecutionException e) {
492 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
495 if (data != null && data.isPresent()) {
496 PreloadData preloadData = data.get().getPreloadData();
497 if (preloadData != null) {
498 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
501 .setPreloadVfModuleTopologyInformation(preloadData.getPreloadVfModuleTopologyInformation());
503 .setPreloadNetworkTopologyInformation(preloadData.getPreloadNetworkTopologyInformation());
504 preloadDataBuilder.setPreloadOperStatus(preloadData.getPreloadOperStatus());
506 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
509 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
513 private void savePreloadList(final PreloadList entry, boolean merge, LogicalDatastoreType storeType)
514 throws IllegalStateException {
516 // Each entry will be identifiable by a unique key, we have to create that
518 InstanceIdentifier.InstanceIdentifierBuilder<PreloadList> preloadListBuilder = InstanceIdentifier
519 .<PreloadInformation>builder(PreloadInformation.class).child(PreloadList.class, entry.getKey());
520 InstanceIdentifier<PreloadList> path = preloadListBuilder.build();
524 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
526 tx.merge(storeType, path, entry);
528 tx.put(storeType, path, entry);
530 tx.submit().checkedGet();
531 log.debug("Update DataStore succeeded");
533 } catch (final TransactionCommitFailedException e) {
534 if (e instanceof OptimisticLockFailedException) {
536 log.debug("Got OptimisticLockFailedException on last try - failing ");
537 throw new IllegalStateException(e);
539 log.debug("Got OptimisticLockFailedException - trying again ");
541 log.debug("Update DataStore failed");
542 throw new IllegalStateException(e);
548 private void deletePreloadList(final PreloadList entry, LogicalDatastoreType storeType) {
549 // Each entry will be identifiable by a unique key, we have to create
551 InstanceIdentifier<PreloadList> path = InstanceIdentifier.builder(PreloadInformation.class)
552 .child(PreloadList.class, entry.getKey()).build();
554 tryDeletePreloadListEntry(storeType, path);
557 private void tryDeletePreloadListEntry(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path) {
561 deletePreloadList(storeType, path);
563 } catch (OptimisticLockFailedException e) {
565 log.debug("Got OptimisticLockFailedException on last try - failing ");
566 throw new IllegalStateException(e);
568 log.debug("Got OptimisticLockFailedException - trying again ");
569 } catch (TransactionCommitFailedException ex) {
570 log.debug("Update DataStore failed");
571 throw new IllegalStateException(ex);
576 private void deletePreloadList(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path)
577 throws TransactionCommitFailedException {
578 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
579 tx.delete(storeType, path);
580 tx.submit().checkedGet();
581 log.debug("DataStore delete succeeded");
585 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
586 ServiceTopologyOperationInput input) {
588 final String svcOperation = "service-topology-operation";
589 ServiceData serviceData;
590 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
591 Properties parms = new Properties();
593 log.info(CALLED_STR, svcOperation);
594 // create a new response object
595 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
597 if (hasInvalidServiceId(input)) {
598 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
599 responseBuilder.setResponseCode("404");
600 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
601 responseBuilder.setAckFinalIndicator("Y");
603 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
604 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
606 return Futures.immediateFuture(rpcResult);
609 // Grab the service instance ID from the input buffer
610 String siid = input.getServiceInformation().getServiceInstanceId();
612 trySetSvcRequestId(input, responseBuilder);
614 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
615 getServiceData(siid, serviceDataBuilder);
617 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
618 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
620 // Set the serviceStatus based on input
621 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
622 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
625 * // setup a service-data object builder // ACTION service-topology-operation
626 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
627 * topology-response-common; // uses service-response-information;
630 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
631 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
632 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
634 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
635 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
637 // Call SLI sync method
638 ResponseObject responseObject = new ResponseObject("200", "");
639 String ackFinal = "Y";
640 String serviceObjectPath = null;
641 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
643 if (respProps != null) {
644 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
645 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
646 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
647 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
650 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
651 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
652 serviceStatusBuilder.setRpcName(svcOperation);
654 if (failed(responseObject)) {
655 responseBuilder.setResponseCode(responseObject.getStatusCode());
656 responseBuilder.setResponseMessage(responseObject.getMessage());
657 responseBuilder.setAckFinalIndicator(ackFinal);
659 ServiceBuilder serviceBuilder = new ServiceBuilder();
660 serviceBuilder.setServiceInstanceId(siid);
661 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
663 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
664 } catch (Exception e) {
665 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
667 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
669 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
670 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
672 return Futures.immediateFuture(rpcResult);
675 // Got success from SLI
677 serviceData = serviceDataBuilder.build();
678 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
681 ServiceBuilder serviceBuilder = new ServiceBuilder();
682 serviceBuilder.setServiceData(serviceData);
683 serviceBuilder.setServiceInstanceId(siid);
684 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
685 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
687 tryDeleteService(input, serviceBuilder);
689 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
690 serviceResponseInformationBuilder.setInstanceId(siid);
691 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
692 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
694 } catch (Exception e) {
695 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
696 responseBuilder.setResponseCode("500");
697 responseBuilder.setResponseMessage(e.getMessage());
698 responseBuilder.setAckFinalIndicator("Y");
699 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
701 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
702 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
704 return Futures.immediateFuture(rpcResult);
708 responseBuilder.setResponseCode(responseObject.getStatusCode());
709 responseBuilder.setAckFinalIndicator(ackFinal);
710 trySetResponseMessage(responseBuilder, responseObject);
711 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
712 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
714 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
715 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
717 return Futures.immediateFuture(rpcResult);
720 private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder,
721 ResponseObject responseObject) {
722 if (responseObject.getMessage() != null) {
723 responseBuilder.setResponseMessage(responseObject.getMessage());
727 private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
728 return input == null || input.getServiceInformation() == null
729 || input.getServiceInformation().getServiceInstanceId() == null
730 || input.getServiceInformation().getServiceInstanceId().length() == 0;
733 private void trySetSvcRequestId(ServiceTopologyOperationInput input,
734 ServiceTopologyOperationOutputBuilder responseBuilder) {
735 if (input.getSdncRequestHeader() != null) {
736 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
740 private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
741 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
742 // Only update operational tree on delete
743 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
744 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
745 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
749 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
750 ResponseObject responseObject) {
752 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
754 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
755 } catch (Exception e) {
756 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
757 responseObject.setMessage(e.getMessage());
758 responseObject.setStatusCode("500");
761 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
762 responseObject.setStatusCode("503");
764 } catch (Exception e) {
765 responseObject.setMessage(e.getMessage());
766 responseObject.setStatusCode("500");
767 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
773 private boolean failed(ResponseObject error) {
774 return !error.getStatusCode().isEmpty()
775 && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
778 private boolean isValidRequest(ServiceTopologyOperationInput input) {
779 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
783 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
785 final String svcOperation = "vnf-topology-operation";
786 ServiceData serviceData;
787 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
788 Properties properties = new Properties();
790 log.info(CALLED_STR, svcOperation);
791 // create a new response object
792 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
794 if (hasInvalidServiceId(input)) {
795 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
796 responseBuilder.setResponseCode("404");
797 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
798 responseBuilder.setAckFinalIndicator("Y");
799 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
800 .withResult(responseBuilder.build()).build();
802 return Futures.immediateFuture(rpcResult);
805 // Grab the service instance ID from the input buffer
806 String siid = input.getServiceInformation().getServiceInstanceId();
808 trySetSvcRequestId(input, responseBuilder);
810 /* Comment out mandatory check for vnf id for scenario wherein for assign/create request vnf-id is generated by
812 if (hasInvalidVnfId(input)) {
813 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
814 responseBuilder.setResponseCode("404");
815 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
816 responseBuilder.setAckFinalIndicator("Y");
818 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
819 .withResult(responseBuilder.build()).build();
821 return Futures.immediateFuture(rpcResult);
825 String vnfId = input.getVnfInformation().getVnfId();
826 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
827 getServiceData(siid, serviceDataBuilder);
829 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
830 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
832 // Set the serviceStatus based on input
833 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
834 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
837 // setup a service-data object builder
838 // ACTION vnf-topology-operation
840 // USES sdnc-request-header;
841 // USES request-information;
842 // USES service-information;
843 // USES vnf-request-information
845 // USES vnf-topology-response-body;
846 // USES vnf-information
847 // USES service-information
849 // container service-data
850 // uses vnf-configuration-information;
853 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
854 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
855 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
857 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
858 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
860 // Call SLI sync method
862 ResponseObject responseObject = new ResponseObject("200", "");
863 String ackFinal = "Y";
864 String serviceObjectPath = null;
865 String vnfObjectPath = null;
866 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
868 if (respProps != null) {
869 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
870 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
871 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
872 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
873 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
876 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
877 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
878 serviceStatusBuilder.setRpcName(svcOperation);
880 if (failed(responseObject)) {
881 responseBuilder.setResponseCode(responseObject.getStatusCode());
882 responseBuilder.setResponseMessage(responseObject.getMessage());
883 responseBuilder.setAckFinalIndicator(ackFinal);
885 ServiceBuilder serviceBuilder = new ServiceBuilder();
886 serviceBuilder.setServiceInstanceId(siid);
887 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
889 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
890 trySaveService(input, serviceBuilder);
891 } catch (Exception e) {
892 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
894 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
896 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
897 .withResult(responseBuilder.build()).build();
900 return Futures.immediateFuture(rpcResult);
903 // Got success from SLI
905 serviceData = serviceDataBuilder.build();
906 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
909 ServiceBuilder serviceBuilder = new ServiceBuilder();
910 serviceBuilder.setServiceData(serviceData);
911 serviceBuilder.setServiceInstanceId(siid);
912 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
913 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
915 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
916 // Only update operational tree on Assign
917 log.info(UPDATING_TREE_INFO_MESSAGE);
918 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
921 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
922 serviceResponseInformationBuilder.setInstanceId(siid);
923 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
924 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
926 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
927 vnfResponseInformationBuilder.setInstanceId(vnfId);
928 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
929 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
931 } catch (Exception e) {
932 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
933 responseBuilder.setResponseCode("500");
934 responseBuilder.setResponseMessage(e.getMessage());
935 responseBuilder.setAckFinalIndicator("Y");
936 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
938 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
939 .withResult(responseBuilder.build()).build();
941 return Futures.immediateFuture(rpcResult);
945 responseBuilder.setResponseCode(responseObject.getStatusCode());
946 responseBuilder.setAckFinalIndicator(ackFinal);
947 trySetResponseMessage(responseBuilder, responseObject);
948 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
949 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
951 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
952 .withResult(responseBuilder.build()).build();
955 return Futures.immediateFuture(rpcResult);
958 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
959 ResponseObject responseObject) {
960 if (responseObject.getMessage() != null) {
961 responseBuilder.setResponseMessage(responseObject.getMessage());
965 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
966 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
967 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
969 // Only update operational tree on activate or delete
970 log.info(UPDATING_TREE_INFO_MESSAGE);
971 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
975 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
976 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
977 || input.getVnfInformation().getVnfId().length() == 0;
980 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
981 return input == null || input.getServiceInformation() == null
982 || input.getServiceInformation().getServiceInstanceId() == null
983 || input.getServiceInformation().getServiceInstanceId().length() == 0;
986 private void trySetSvcRequestId(VnfTopologyOperationInput input,
987 VnfTopologyOperationOutputBuilder responseBuilder) {
988 if (input.getSdncRequestHeader() != null) {
989 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
993 private boolean isValidRequest(VnfTopologyOperationInput input) {
994 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
998 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
999 VfModuleTopologyOperationInput input) {
1001 final String svcOperation = "vf-module-topology-operation";
1002 ServiceData serviceData;
1003 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1004 Properties parms = new Properties();
1006 log.info(CALLED_STR, svcOperation);
1007 // create a new response object
1008 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1010 if (hasInvalidServiceId(input)) {
1011 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1012 responseBuilder.setResponseCode("403");
1013 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1014 responseBuilder.setAckFinalIndicator("Y");
1016 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1017 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1020 return Futures.immediateFuture(rpcResult);
1023 if (hasInvalidVnfId(input)) {
1024 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1025 responseBuilder.setResponseCode("403");
1026 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1027 responseBuilder.setAckFinalIndicator("Y");
1028 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1029 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1030 return Futures.immediateFuture(rpcResult);
1033 if (hasInvalidVfModuleId(input)) {
1034 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1035 responseBuilder.setResponseCode("403");
1036 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1037 responseBuilder.setAckFinalIndicator("Y");
1039 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1040 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1042 return Futures.immediateFuture(rpcResult);
1045 // Grab the service instance ID from the input buffer
1046 String siid = input.getServiceInformation().getServiceInstanceId();
1047 String vnfId = input.getVnfInformation().getVnfId();
1048 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1050 trySetSvcRequestId(input, responseBuilder);
1052 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1053 getServiceData(siid, serviceDataBuilder);
1055 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1056 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1058 // Set the serviceStatus based on input
1059 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1060 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1063 // setup a service-data object builder
1064 // ACTION vnf-topology-operation
1066 // USES sdnc-request-header;
1067 // USES request-information;
1068 // USES service-information;
1069 // USES vnf-request-information
1071 // USES vnf-topology-response-body;
1072 // USES vnf-information
1073 // USES service-information
1075 // container service-data
1076 // uses vnf-configuration-information;
1077 // uses oper-status;
1079 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1080 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1081 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1083 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1084 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1086 // Call SLI sync method
1088 ResponseObject responseObject = new ResponseObject("200", "");
1089 String ackFinal = "Y";
1090 String serviceObjectPath = null;
1091 String vnfObjectPath = null;
1092 String vfModuleObjectPath = null;
1093 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1095 if (respProps != null) {
1096 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1097 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1098 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1099 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1100 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1101 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1104 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1105 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1106 serviceStatusBuilder.setRpcName(svcOperation);
1108 if (failed(responseObject)) {
1109 responseBuilder.setResponseCode(responseObject.getStatusCode());
1110 responseBuilder.setResponseMessage(responseObject.getMessage());
1111 responseBuilder.setAckFinalIndicator(ackFinal);
1113 ServiceBuilder serviceBuilder = new ServiceBuilder();
1114 serviceBuilder.setServiceInstanceId(siid);
1115 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1117 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1118 } catch (Exception e) {
1119 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1121 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1123 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1124 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1127 return Futures.immediateFuture(rpcResult);
1130 // Got success from SLI
1132 serviceData = serviceDataBuilder.build();
1133 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1136 ServiceBuilder serviceBuilder = new ServiceBuilder();
1137 serviceBuilder.setServiceData(serviceData);
1138 serviceBuilder.setServiceInstanceId(siid);
1139 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1140 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1142 trySaveService(input, serviceBuilder);
1144 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1145 serviceResponseInformationBuilder.setInstanceId(siid);
1146 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1147 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1149 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1150 vnfResponseInformationBuilder.setInstanceId(vnfId);
1151 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1152 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1154 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1155 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1156 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1157 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1159 } catch (Exception e) {
1160 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1161 responseBuilder.setResponseCode("500");
1162 responseBuilder.setResponseMessage(e.getMessage());
1163 responseBuilder.setAckFinalIndicator("Y");
1164 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1166 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1167 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1169 return Futures.immediateFuture(rpcResult);
1173 responseBuilder.setResponseCode(responseObject.getStatusCode());
1174 responseBuilder.setAckFinalIndicator(ackFinal);
1175 trySetResponseMessage(responseBuilder, responseObject);
1176 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1177 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1179 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1180 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1183 return Futures.immediateFuture(rpcResult);
1186 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1187 ResponseObject responseObject) {
1188 if (responseObject.getMessage() != null) {
1189 responseBuilder.setResponseMessage(responseObject.getMessage());
1193 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1194 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1195 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1196 // Only update operational tree on activate or delete
1198 log.info(UPDATING_TREE_INFO_MESSAGE);
1199 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1203 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1204 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1205 if (input.getSdncRequestHeader() != null) {
1206 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1210 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1211 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1212 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1215 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1216 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1217 || input.getVnfInformation().getVnfId().length() == 0;
1220 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1221 return input == null || input.getServiceInformation() == null
1222 || input.getServiceInformation().getServiceInstanceId() == null
1223 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1226 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1227 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1231 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1232 NetworkTopologyOperationInput input) {
1234 final String svcOperation = "network-topology-operation";
1235 ServiceData serviceData;
1236 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1237 Properties parms = new Properties();
1239 log.info(CALLED_STR, svcOperation);
1240 // create a new response object
1241 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1243 if (hasInvalidServiceId(input)) {
1244 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1245 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1248 String siid = input.getServiceInformation().getServiceInstanceId();
1250 // Get the service-instance service data from MD-SAL
1251 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1252 getServiceData(siid, serviceDataBuilder);
1254 this.trySetSvcRequestId(input, responseBuilder);
1256 ServiceData sd = serviceDataBuilder.build();
1257 if (isInvalidServiceData(sd)) {
1258 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1259 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1262 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1263 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1264 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1266 // Call SLI sync method
1268 ResponseObject responseObject = new ResponseObject("200", "");
1269 String ackFinal = "Y";
1270 String networkId = ERROR_NETWORK_ID;
1271 String serviceObjectPath = null;
1272 String networkObjectPath = null;
1273 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1275 if (respProps != null) {
1276 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1277 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1278 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1279 networkId = respProps.getProperty("networkId");
1280 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1281 networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1284 if (failed(responseObject)) {
1285 responseBuilder.setResponseCode(responseObject.getStatusCode());
1286 responseBuilder.setResponseMessage(responseObject.getMessage());
1287 responseBuilder.setAckFinalIndicator(ackFinal);
1289 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1291 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1292 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1294 return Futures.immediateFuture(rpcResult);
1297 // Got success from SLI
1300 serviceData = serviceDataBuilder.build();
1301 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1304 ServiceBuilder serviceBuilder = new ServiceBuilder();
1305 serviceBuilder.setServiceData(serviceData);
1306 serviceBuilder.setServiceInstanceId(siid);
1307 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1308 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1310 trySaveService(input, serviceBuilder);
1312 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1313 networkResponseInformationBuilder.setInstanceId(networkId);
1314 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1315 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1317 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1318 serviceResponseInformationBuilder.setInstanceId(siid);
1319 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1320 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1322 } catch (IllegalStateException e) {
1323 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1324 responseBuilder.setResponseCode("500");
1325 responseBuilder.setResponseMessage(e.getMessage());
1326 responseBuilder.setAckFinalIndicator("Y");
1327 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1329 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1330 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1332 return Futures.immediateFuture(rpcResult);
1336 responseBuilder.setResponseCode(responseObject.getStatusCode());
1337 responseBuilder.setAckFinalIndicator(ackFinal);
1338 trySetResponseMessage(responseBuilder, responseObject);
1339 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1340 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1342 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1343 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1345 return Futures.immediateFuture(rpcResult);
1348 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1349 ResponseObject responseObject) {
1350 if (responseObject.getMessage() != null) {
1351 responseBuilder.setResponseMessage(responseObject.getMessage());
1355 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1356 NetworkTopologyOperationOutputBuilder responseBuilder) {
1357 if (input.getSdncRequestHeader() != null) {
1358 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1362 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1363 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1364 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1365 // Only update operational tree on Activate
1366 log.info(UPDATING_TREE_INFO_MESSAGE);
1367 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1371 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1372 return input == null || input.getServiceInformation() == null
1373 || input.getServiceInformation().getServiceInstanceId() == null
1374 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1377 private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1378 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1380 responseBuilder.setResponseCode("404");
1381 responseBuilder.setResponseMessage(responseMessage);
1382 responseBuilder.setAckFinalIndicator("Y");
1384 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1385 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1387 return Futures.immediateFuture(rpcResult);
1390 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1391 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1395 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1396 ContrailRouteTopologyOperationInput input) {
1398 final String svcOperation = "contrail-route-topology-operation";
1399 ServiceData serviceData;
1400 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1401 Properties properties = new Properties();
1403 log.info(CALLED_STR, svcOperation);
1404 // create a new response object
1405 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1407 if (hasInvalidServiceId(input)) {
1408 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1409 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1412 String siid = input.getServiceInformation().getServiceInstanceId();
1414 // Get the service-instance service data from MD-SAL
1415 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1416 getServiceData(siid, serviceDataBuilder);
1418 trySetSvcRequestId(input, responseBuilder);
1420 ServiceData sd = serviceDataBuilder.build();
1421 if (isInvalidServiceData(sd)) {
1422 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1423 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1426 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1427 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1428 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1430 // Call SLI sync method
1432 ResponseObject responseObject = new ResponseObject("200", "");
1433 String ackFinal = "Y";
1434 String allottedResourceId = ERROR_NETWORK_ID;
1435 String serviceObjectPath = null;
1436 String contrailRouteObjectPath = null;
1437 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1439 if (respProps != null) {
1440 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1441 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1442 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1443 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1444 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1445 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1448 if (failed(responseObject)) {
1449 responseBuilder.setResponseCode(responseObject.getStatusCode());
1450 responseBuilder.setResponseMessage(responseObject.getMessage());
1451 responseBuilder.setAckFinalIndicator(ackFinal);
1452 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1454 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1455 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1457 return Futures.immediateFuture(rpcResult);
1460 // Got success from SLI
1462 serviceData = serviceDataBuilder.build();
1463 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1466 ServiceBuilder serviceBuilder = new ServiceBuilder();
1467 serviceBuilder.setServiceData(serviceData);
1468 serviceBuilder.setServiceInstanceId(siid);
1469 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1470 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1472 trySaveService(input, serviceBuilder);
1474 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1475 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1476 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1477 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1479 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1480 serviceResponseInformationBuilder.setInstanceId(siid);
1481 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1482 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1484 } catch (IllegalStateException e) {
1485 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1486 responseBuilder.setResponseCode("500");
1487 responseBuilder.setResponseMessage(e.getMessage());
1488 responseBuilder.setAckFinalIndicator("Y");
1489 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1491 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1492 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1494 return Futures.immediateFuture(rpcResult);
1498 responseBuilder.setResponseCode(responseObject.getStatusCode());
1499 responseBuilder.setAckFinalIndicator(ackFinal);
1500 trySetResponseMessage(responseBuilder, responseObject);
1501 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1502 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1504 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1505 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1507 return Futures.immediateFuture(rpcResult);
1510 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1511 ResponseObject responseObject) {
1512 if (responseObject.getMessage() != null) {
1513 responseBuilder.setResponseMessage(responseObject.getMessage());
1517 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1518 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1519 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1520 // Only update operational tree on activate or delete
1521 log.info(UPDATING_TREE_INFO_MESSAGE);
1522 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1526 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1527 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1528 if (input.getSdncRequestHeader() != null) {
1529 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1533 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1534 return input == null || input.getServiceInformation() == null
1535 || input.getServiceInformation().getServiceInstanceId() == null
1536 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1539 private Future<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
1540 ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1541 responseBuilder.setResponseCode("404");
1542 responseBuilder.setResponseMessage(responseMessage);
1543 responseBuilder.setAckFinalIndicator("Y");
1545 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1546 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1548 return Futures.immediateFuture(rpcResult);
1551 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1552 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1556 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1557 SecurityZoneTopologyOperationInput input) {
1559 final String svcOperation = "security-zone-topology-operation";
1560 ServiceData serviceData;
1561 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1562 Properties parms = new Properties();
1564 log.info(CALLED_STR, svcOperation);
1565 // create a new response object
1566 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1568 if (this.hasInvalidServiceId(input)) {
1569 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1570 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1573 String siid = input.getServiceInformation().getServiceInstanceId();
1575 // Get the service-instance service data from MD-SAL
1576 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1577 getServiceData(siid, serviceDataBuilder);
1578 trySetSvcRequestId(input, responseBuilder);
1580 ServiceData sd = serviceDataBuilder.build();
1581 if (isInvalidServiceData(sd)) {
1582 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1583 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1586 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1587 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1588 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1590 // Call SLI sync method
1592 Properties respProps = null;
1594 ResponseObject responseObject = new ResponseObject("200", "");
1595 String ackFinal = "Y";
1596 String allottedResourceId = ERROR_NETWORK_ID;
1597 String serviceObjectPath = null;
1598 String securityZoneObjectPath = null;
1601 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1604 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1605 } catch (Exception e) {
1606 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1607 responseObject.setMessage(e.getMessage());
1608 responseObject.setStatusCode("500");
1611 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1612 responseObject.setStatusCode("503");
1614 } catch (Exception e) {
1615 responseObject.setStatusCode("500");
1616 responseObject.setMessage(e.getMessage());
1617 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1620 if (respProps != null) {
1621 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1622 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1623 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1624 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1625 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1626 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1629 if (failed(responseObject)) {
1630 responseBuilder.setResponseCode(responseObject.getStatusCode());
1631 responseBuilder.setResponseMessage(responseObject.getMessage());
1632 responseBuilder.setAckFinalIndicator(ackFinal);
1633 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1635 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1636 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1638 return Futures.immediateFuture(rpcResult);
1641 // Got success from SLI
1644 serviceData = serviceDataBuilder.build();
1645 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1648 ServiceBuilder serviceBuilder = new ServiceBuilder();
1649 serviceBuilder.setServiceData(serviceData);
1650 serviceBuilder.setServiceInstanceId(siid);
1651 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1652 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1654 trySaveService(input, serviceBuilder);
1656 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1657 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1658 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1659 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1661 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1662 serviceResponseInformationBuilder.setInstanceId(siid);
1663 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1664 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1666 } catch (IllegalStateException e) {
1667 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1668 responseBuilder.setResponseCode("500");
1669 responseBuilder.setResponseMessage(e.getMessage());
1670 responseBuilder.setAckFinalIndicator("Y");
1671 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1673 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1674 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1676 return Futures.immediateFuture(rpcResult);
1680 responseBuilder.setResponseCode(responseObject.getStatusCode());
1681 responseBuilder.setAckFinalIndicator(ackFinal);
1682 trySetResponseMessage(responseBuilder, responseObject);
1683 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1684 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1686 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1687 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1689 return Futures.immediateFuture(rpcResult);
1692 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1693 ResponseObject responseObject) {
1694 if (responseObject.getMessage() != null) {
1695 responseBuilder.setResponseMessage(responseObject.getMessage());
1699 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1700 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1701 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1702 // Only update operational tree on activate or delete
1703 log.info(UPDATING_TREE_INFO_MESSAGE);
1704 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1708 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1709 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1710 if (input.getSdncRequestHeader() != null) {
1711 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1715 private boolean isInvalidServiceData(ServiceData sd) {
1716 return sd == null || sd.getServiceLevelOperStatus() == null;
1719 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1720 return input == null || input.getServiceInformation() == null
1721 || input.getServiceInformation().getServiceInstanceId() == null
1722 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1725 private Future<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
1726 SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1728 responseBuilder.setResponseCode("404");
1729 responseBuilder.setResponseMessage(responseMessage);
1730 responseBuilder.setAckFinalIndicator("Y");
1732 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1733 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1735 return Futures.immediateFuture(rpcResult);
1738 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1739 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1743 private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
1744 return input == null || input.getServiceInformation() == null
1745 || input.getServiceInformation().getServiceInstanceId() == null
1746 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1749 private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
1750 ResponseObject error) {
1751 if (!error.getMessage().isEmpty()) {
1752 responseBuilder.setResponseMessage(error.getMessage());
1756 private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
1757 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
1758 if (input.getSdncRequestHeader() != null) {
1759 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1763 private Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
1764 buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1766 responseBuilder.setResponseCode("404");
1767 responseBuilder.setResponseMessage(responseMessage);
1768 responseBuilder.setAckFinalIndicator("Y");
1770 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1771 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1772 .withResult(responseBuilder.build())
1775 return Futures.immediateFuture(rpcResult);
1778 private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1779 if (isValidRequest(input) &&
1780 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1781 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1782 // Only update operational tree on activate or delete
1783 log.info(UPDATING_TREE_INFO_MESSAGE);
1784 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1788 private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
1789 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1793 public Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(ConnectionAttachmentTopologyOperationInput input) {
1794 final String svcOperation = "connection-attachment-topology-operation";
1795 Properties parms = new Properties();
1796 log.info(CALLED_STR, svcOperation);
1798 // create a new response object
1799 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
1800 if (hasInvalidServiceId(input)) {
1801 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1802 responseBuilder.setResponseCode("404");
1803 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1804 responseBuilder.setAckFinalIndicator("Y");
1806 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1807 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1808 .withResult(responseBuilder.build())
1811 return Futures.immediateFuture(rpcResult);
1814 ServiceData serviceData;
1815 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1816 Properties properties = new Properties();
1818 String siid = input.getServiceInformation().getServiceInstanceId();
1819 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1821 // Get the service-instance service data from MD-SAL
1822 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1823 getServiceData(siid, serviceDataBuilder);
1825 trySetSvcRequestId(input, responseBuilder);
1827 ServiceData sd = serviceDataBuilder.build();
1828 if (isInvalidServiceData(sd)) {
1829 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1830 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1833 ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(input);
1834 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1836 // Call SLI sync method
1837 // Get SvcLogicService reference
1838 ResponseObject responseObject = new ResponseObject("200", "");
1839 String ackFinal = "Y";
1840 String allottedResourceId = ERROR_NETWORK_ID;
1841 String serviceObjectPath = null;
1842 String connectionAttachmentObjectPath = null;
1844 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1846 if (respProps != null) {
1847 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1848 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1849 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1850 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1851 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1852 connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
1855 if (failed(responseObject)) {
1856 responseBuilder.setResponseCode(responseObject.getStatusCode());
1857 responseBuilder.setResponseMessage(responseObject.getMessage());
1858 responseBuilder.setAckFinalIndicator(ackFinal);
1860 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1862 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1863 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1864 .withResult(responseBuilder.build())
1867 return Futures.immediateFuture(rpcResult);
1870 // Got success from SLI
1873 serviceData = serviceDataBuilder.build();
1874 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1877 ServiceBuilder serviceBuilder = new ServiceBuilder();
1878 serviceBuilder.setServiceData(serviceData);
1879 serviceBuilder.setServiceInstanceId(siid);
1880 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1881 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1883 trySaveService(input, serviceBuilder);
1885 ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
1886 connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
1887 connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
1888 responseBuilder.setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
1890 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1891 serviceResponseInformationBuilder.setInstanceId(siid);
1892 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1893 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1895 } catch (IllegalStateException e) {
1896 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1897 responseBuilder.setResponseCode("500");
1898 responseBuilder.setResponseMessage(e.getMessage());
1899 responseBuilder.setAckFinalIndicator("Y");
1900 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1902 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1903 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1904 .withResult(responseBuilder.build())
1907 return Futures.immediateFuture(rpcResult);
1911 responseBuilder.setResponseCode(responseObject.getStatusCode());
1912 responseBuilder.setAckFinalIndicator(ackFinal);
1913 trySetResponseMessage(responseBuilder, responseObject);
1914 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1915 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1917 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1918 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1919 .withResult(responseBuilder.build())
1922 return Futures.immediateFuture(rpcResult);
1926 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1927 TunnelxconnTopologyOperationInput input) {
1929 final String svcOperation = "tunnelxconn-topology-operation";
1930 Properties parms = new Properties();
1931 log.info(CALLED_STR, svcOperation);
1933 // create a new response object
1934 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1935 if (hasInvalidServiceId(input)) {
1936 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1937 responseBuilder.setResponseCode("404");
1938 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1939 responseBuilder.setAckFinalIndicator("Y");
1941 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1942 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1944 return Futures.immediateFuture(rpcResult);
1946 String siid = input.getServiceInformation().getServiceInstanceId();
1947 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1948 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1949 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1951 // Call SLI sync method
1953 ResponseObject responseObject = new ResponseObject("200", "");
1954 String ackFinal = "Y";
1955 String allottedResourceId = ERROR_NETWORK_ID;
1956 String serviceObjectPath = null;
1957 String tunnelxconnObjectPath = null;
1958 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1960 if (respProps != null) {
1961 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1962 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1963 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1964 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1965 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1966 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1969 if (failed(responseObject)) {
1970 responseBuilder.setResponseCode(responseObject.getStatusCode());
1971 responseBuilder.setResponseMessage(responseObject.getMessage());
1972 responseBuilder.setAckFinalIndicator(ackFinal);
1974 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1976 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1977 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1979 return Futures.immediateFuture(rpcResult);
1982 // Got success from SLI
1984 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1985 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1986 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1987 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1989 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1990 serviceResponseInformationBuilder.setInstanceId(siid);
1991 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1992 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1994 } catch (IllegalStateException e) {
1995 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1996 responseBuilder.setResponseCode("500");
1997 responseBuilder.setResponseMessage(e.getMessage());
1998 responseBuilder.setAckFinalIndicator("Y");
1999 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2001 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2002 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2004 return Futures.immediateFuture(rpcResult);
2008 responseBuilder.setResponseCode(responseObject.getStatusCode());
2009 responseBuilder.setAckFinalIndicator(ackFinal);
2010 trySetResponseMessage(responseBuilder, responseObject);
2011 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2012 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2014 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2015 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2017 return Futures.immediateFuture(rpcResult);
2020 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2021 ResponseObject responseObject) {
2022 if (responseObject.getMessage() != null) {
2023 responseBuilder.setResponseMessage(responseObject.getMessage());
2027 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2028 return input == null || input.getServiceInformation() == null
2029 || input.getServiceInformation().getServiceInstanceId() == null
2030 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2033 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2035 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2038 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2039 } catch (Exception e) {
2040 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2041 responseObject.setMessage(e.getMessage());
2042 responseObject.setStatusCode("500");
2045 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2046 responseObject.setStatusCode("503");
2048 } catch (Exception e) {
2049 responseObject.setMessage(e.getMessage());
2050 responseObject.setStatusCode("500");
2051 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2057 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
2058 final String svcOperation = "brg-topology-operation";
2059 Properties parms = new Properties();
2061 log.info(CALLED_STR, svcOperation);
2062 // create a new response object
2063 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2065 if (this.hasInvalidServiceId(input)) {
2067 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2068 responseBuilder.setResponseCode("404");
2069 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2070 responseBuilder.setAckFinalIndicator("Y");
2072 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2073 .withResult(responseBuilder.build()).build();
2075 return Futures.immediateFuture(rpcResult);
2078 String siid = input.getServiceInformation().getServiceInstanceId();
2080 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2081 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2082 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2084 // Call SLI sync method
2086 ResponseObject responseObject = new ResponseObject("200", "");
2087 String ackFinal = "Y";
2088 String allottedResourceId = ERROR_NETWORK_ID;
2089 String serviceObjectPath = null;
2090 String brgObjectPath = null;
2091 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2093 if (respProps != null) {
2094 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2095 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2096 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2097 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2098 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2099 brgObjectPath = respProps.getProperty("brg-object-path");
2102 if (failed(responseObject)) {
2103 responseBuilder.setResponseCode(responseObject.getStatusCode());
2104 responseBuilder.setResponseMessage(responseObject.getMessage());
2105 responseBuilder.setAckFinalIndicator(ackFinal);
2107 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2108 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2109 .withResult(responseBuilder.build()).build();
2111 return Futures.immediateFuture(rpcResult);
2114 // Got success from SLI
2117 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2118 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2119 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2120 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2122 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2123 serviceResponseInformationBuilder.setInstanceId(siid);
2124 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2125 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2127 } catch (IllegalStateException e) {
2128 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2129 responseBuilder.setResponseCode("500");
2130 responseBuilder.setResponseMessage(e.getMessage());
2131 responseBuilder.setAckFinalIndicator("Y");
2132 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2134 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2135 .withResult(responseBuilder.build()).build();
2137 return Futures.immediateFuture(rpcResult);
2141 responseBuilder.setResponseCode(responseObject.getStatusCode());
2142 responseBuilder.setAckFinalIndicator(ackFinal);
2143 trySetResponseMessage(responseBuilder, responseObject);
2144 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2145 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2147 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2148 .withResult(responseBuilder.build()).build();
2150 return Futures.immediateFuture(rpcResult);
2153 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2154 ResponseObject responseObject) {
2155 if (responseObject.getMessage() != null) {
2156 responseBuilder.setResponseMessage(responseObject.getMessage());
2160 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2161 return input == null || input.getServiceInformation() == null
2162 || input.getServiceInformation().getServiceInstanceId() == null
2163 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2166 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2167 if (respProps != null) {
2168 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2169 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2170 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2176 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2177 PreloadNetworkTopologyOperationInput input) {
2179 final String svcOperation = "preload-network-topology-operation";
2180 PreloadData preloadData;
2181 Properties properties = new Properties();
2183 log.info(CALLED_STR, svcOperation);
2184 // create a new response object
2185 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2187 if (hasInvalidPreloadNetwork(input)) {
2188 log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2189 responseBuilder.setResponseCode("403");
2190 responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2191 responseBuilder.setAckFinalIndicator("Y");
2193 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2194 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2196 return Futures.immediateFuture(rpcResult);
2199 // Grab the preload ID from the input buffer
2200 String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2202 String preloadType = "network";
2204 trySetSvcRequestId(input, responseBuilder);
2206 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2207 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2209 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2210 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2213 // setup a preload-data object builder
2214 // ACTION preload-network-topology-operation
2216 // uses sdnc-request-header;
2217 // uses request-information;
2218 // uses preload-network-topology-information;
2220 // uses preload-topology-response-body;
2222 // container preload-data
2223 // uses preload-network-topology-information;
2224 // uses preload-oper-status;
2226 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2227 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2229 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2230 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2231 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2233 // Call SLI sync method
2234 ResponseObject responseObject = new ResponseObject("200", "");
2235 String ackFinal = "Y";
2236 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2238 if (respProps != null) {
2239 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2240 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2241 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2244 if (failed(responseObject)) {
2245 responseBuilder.setResponseCode(responseObject.getStatusCode());
2246 responseBuilder.setResponseMessage(responseObject.getMessage());
2247 responseBuilder.setAckFinalIndicator(ackFinal);
2248 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2249 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2250 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2251 return Futures.immediateFuture(rpcResult);
2254 // Got success from SLI
2256 preloadData = preloadDataBuilder.build();
2257 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2259 // preload-list object
2260 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2261 preloadListBuilder.setPreloadId(preloadId);
2262 preloadListBuilder.setPreloadType(preloadType);
2263 preloadListBuilder.setPreloadData(preloadData);
2265 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2266 log.info(UPDATING_TREE_INFO_MESSAGE);
2267 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2269 tryDeletePreload(input, preloadListBuilder);
2270 } catch (Exception e) {
2271 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2272 responseBuilder.setResponseCode("500");
2273 responseBuilder.setResponseMessage(e.getMessage());
2274 responseBuilder.setAckFinalIndicator("Y");
2275 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2276 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2277 .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2278 return Futures.immediateFuture(rpcResult);
2282 responseBuilder.setResponseCode(responseObject.getStatusCode());
2283 responseBuilder.setAckFinalIndicator(ackFinal);
2284 trySetResponseMessage(responseBuilder, responseObject);
2285 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2286 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2288 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2289 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2290 return Futures.immediateFuture(rpcResult);
2293 private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2294 return input == null || input.getPreloadNetworkTopologyInformation() == null
2295 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2298 private boolean hasInvalidPreloadId(String preloadId) {
2299 return preloadId == null || preloadId.length() == 0;
2302 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2303 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2304 if (input.getSdncRequestHeader() != null) {
2305 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2309 private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2310 ResponseObject responseObject) {
2312 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2314 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2315 } catch (Exception e) {
2316 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2317 responseObject.setMessage(e.getMessage());
2318 responseObject.setStatusCode("500");
2321 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2322 responseObject.setStatusCode("503");
2324 } catch (Exception e) {
2325 responseObject.setMessage(e.getMessage());
2326 responseObject.setStatusCode("500");
2327 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2333 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2334 ResponseObject responseObject) {
2335 if (responseObject.getMessage() != null) {
2336 if (!responseObject.getMessage().isEmpty()) {
2337 responseBuilder.setResponseMessage(responseObject.getMessage());
2342 private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2343 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2344 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2345 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2346 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2351 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2352 PreloadVfModuleTopologyOperationInput input) {
2354 final String svcOperation = "preload-vf-module-topology-operation";
2355 PreloadData preloadData;
2356 Properties properties = new Properties();
2358 log.info(CALLED_STR, svcOperation);
2359 // create a new response object
2360 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2362 if (hasInvalidPreloadVfModule(input)) {
2364 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2366 responseBuilder.setResponseCode("403");
2367 responseBuilder.setResponseMessage(
2368 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2369 responseBuilder.setAckFinalIndicator("Y");
2371 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2372 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2374 return Futures.immediateFuture(rpcResult);
2377 // Grab the preload ID from the input buffer
2378 String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2379 .getVfModuleTopologyIdentifier().getVfModuleName();
2380 String preloadType = "vf-module";
2382 trySetSvcRequestId(input, responseBuilder);
2384 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2385 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2387 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2388 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2391 // setup a preload-data object builder
2392 // ACTION preload-vf-module-topology-operation
2394 // uses sdnc-request-header;
2395 // uses request-information;
2396 // uses preload-vnf-topology-information;
2398 // uses preload-topology-response-body;
2400 // container preload-data
2401 // uses preload-vf-module-topology-information;
2402 // uses preload-oper-status;
2404 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2405 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2407 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2408 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2409 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2411 // Call SLI sync method
2412 ResponseObject responseObject = new ResponseObject("200", "");
2413 String ackFinal = "Y";
2414 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2416 if (respProps != null) {
2417 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2418 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2419 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2422 if (failed(responseObject)) {
2423 responseBuilder.setResponseCode(responseObject.getStatusCode());
2424 responseBuilder.setResponseMessage(responseObject.getMessage());
2425 responseBuilder.setAckFinalIndicator(ackFinal);
2426 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2427 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2428 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2429 return Futures.immediateFuture(rpcResult);
2432 // Got success from SLI
2434 preloadData = preloadDataBuilder.build();
2435 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2437 // preload-list object
2438 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2439 preloadListBuilder.setPreloadId(preloadId);
2440 preloadListBuilder.setPreloadType(preloadType);
2441 preloadListBuilder.setPreloadData(preloadData);
2443 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2444 log.info(UPDATING_TREE_INFO_MESSAGE);
2445 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2447 tryDeletePreload(input, preloadListBuilder);
2449 } catch (Exception e) {
2450 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2451 responseBuilder.setResponseCode("500");
2452 responseBuilder.setResponseMessage(e.getMessage());
2453 responseBuilder.setAckFinalIndicator("Y");
2454 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2455 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2456 .<PreloadVfModuleTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2457 return Futures.immediateFuture(rpcResult);
2461 responseBuilder.setResponseCode(responseObject.getStatusCode());
2462 responseBuilder.setAckFinalIndicator(ackFinal);
2463 trySetResponseMessage(responseBuilder, responseObject);
2464 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2465 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2467 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2468 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2469 return Futures.immediateFuture(rpcResult);
2472 private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
2473 return input == null || input.getPreloadVfModuleTopologyInformation() == null
2474 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
2475 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2476 .getVfModuleTopologyIdentifier() == null
2477 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
2478 .getVfModuleName() == null;
2481 private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
2482 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
2483 if (input.getSdncRequestHeader() != null) {
2484 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2488 private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
2489 ResponseObject responseObject) {
2490 if (responseObject.getMessage() != null) {
2491 if (!responseObject.getMessage().isEmpty()) {
2492 responseBuilder.setResponseMessage(responseObject.getMessage());
2497 private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2498 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2499 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2500 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2501 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2506 public Future<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
2507 GenericConfigurationTopologyOperationInput input) {
2509 final String svcOperation = "generic-configuration-topology-operation";
2510 ServiceData serviceData;
2511 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2512 Properties parms = new Properties();
2514 log.info(CALLED_STR, svcOperation);
2515 // create a new response object
2516 GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
2518 if (hasInvalidService(input)) {
2519 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2520 responseBuilder.setResponseCode("404");
2521 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2522 responseBuilder.setAckFinalIndicator("Y");
2524 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2525 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2528 return Futures.immediateFuture(rpcResult);
2531 // Grab the service instance ID from the input buffer
2532 String siid = input.getServiceInformation().getServiceInstanceId();
2534 trySetSvcRequestId(input, responseBuilder);
2536 if (hasInvalidConfigurationIdOrType(input)) {
2537 log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
2538 responseBuilder.setResponseCode("404");
2539 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
2540 responseBuilder.setAckFinalIndicator("Y");
2541 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2542 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2544 return Futures.immediateFuture(rpcResult);
2547 // Grab the configuration ID from the input buffer
2548 String configId = input.getConfigurationInformation().getConfigurationId();
2550 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2551 getServiceData(siid, serviceDataBuilder);
2553 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2554 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2556 // Set the serviceStatus based on input
2557 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2558 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2560 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2561 GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
2563 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2565 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2566 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2568 // Call SLI sync method
2570 ResponseObject responseObject = new ResponseObject("200", "");
2571 String ackFinal = "Y";
2572 String serviceObjectPath = "";
2573 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2575 if (respProps != null) {
2576 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2577 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2578 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2579 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2582 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2583 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2584 serviceStatusBuilder.setRpcName(svcOperation);
2586 if (failed(responseObject)) {
2587 responseBuilder.setResponseCode(responseObject.getStatusCode());
2588 responseBuilder.setResponseMessage(responseObject.getMessage());
2589 responseBuilder.setAckFinalIndicator(ackFinal);
2591 ServiceBuilder serviceBuilder = new ServiceBuilder();
2592 serviceBuilder.setServiceInstanceId(siid);
2593 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2595 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2596 } catch (Exception e) {
2597 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2599 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2601 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2602 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2605 return Futures.immediateFuture(rpcResult);
2608 // Got success from SLI
2610 serviceData = serviceDataBuilder.build();
2613 ServiceBuilder serviceBuilder = new ServiceBuilder();
2614 serviceBuilder.setServiceData(serviceData);
2615 serviceBuilder.setServiceInstanceId(siid);
2616 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2617 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2619 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2620 serviceResponseInformationBuilder.setInstanceId(siid);
2621 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2622 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2623 GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
2624 gcResponseInformationBuilder.setInstanceId(configId);
2625 responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
2627 } catch (Exception e) {
2628 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2629 responseBuilder.setResponseCode("500");
2630 responseBuilder.setResponseMessage(e.getMessage());
2631 responseBuilder.setAckFinalIndicator("Y");
2632 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2633 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2636 return Futures.immediateFuture(rpcResult);
2640 responseBuilder.setResponseCode(responseObject.getStatusCode());
2641 responseBuilder.setAckFinalIndicator(ackFinal);
2642 trySetResponseMessage(responseBuilder, responseObject);
2643 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2644 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2646 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2647 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2649 return Futures.immediateFuture(rpcResult);
2652 private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
2653 return input == null || input.getServiceInformation() == null
2654 || input.getServiceInformation().getServiceInstanceId() == null
2655 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2658 private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
2659 GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
2660 if (input.getSdncRequestHeader() != null) {
2661 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2665 private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
2666 return input.getConfigurationInformation() == null
2667 || input.getConfigurationInformation().getConfigurationId() == null
2668 || input.getConfigurationInformation().getConfigurationType() == null;
2671 private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
2672 ResponseObject responseObject) {
2673 if (responseObject.getMessage() != null) {
2674 if (!responseObject.getMessage().isEmpty()) {
2675 responseBuilder.setResponseMessage(responseObject.getMessage());
2681 public Future<RpcResult<Void>> genericConfigurationNotification(GenericConfigurationNotificationInput input) {
2683 final String svcOperation = "generic-configuration-notification";
2684 ServiceData serviceData;
2685 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2686 Properties parms = new Properties();
2688 log.info(CALLED_STR, svcOperation);
2690 // Grab the service instance ID from the input buffer
2691 String siid = input.getServiceInformation().getServiceInstanceId();
2693 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2694 getServiceData(siid, serviceDataBuilder);
2696 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2697 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2699 // Set the serviceStatus based on input
2700 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2701 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2703 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2704 GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
2706 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2708 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2709 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2711 // Call SLI sync method
2713 ResponseObject responseObject = new ResponseObject("200", "");
2714 String ackFinal = "Y";
2715 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2717 if (respProps != null) {
2718 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2719 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2720 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2723 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2724 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2725 serviceStatusBuilder.setRpcName(svcOperation);
2727 if (failed(responseObject)) {
2728 ServiceBuilder serviceBuilder = new ServiceBuilder();
2729 serviceBuilder.setServiceInstanceId(siid);
2730 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2732 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2733 } catch (Exception e) {
2734 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2737 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2739 return Futures.immediateFuture(rpcResult);
2742 // Got success from SLI
2744 serviceData = serviceDataBuilder.build();
2747 ServiceBuilder serviceBuilder = new ServiceBuilder();
2748 serviceBuilder.setServiceData(serviceData);
2749 serviceBuilder.setServiceInstanceId(siid);
2750 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2751 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2753 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2754 serviceResponseInformationBuilder.setInstanceId(siid);
2756 } catch (Exception e) {
2757 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2758 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2760 return Futures.immediateFuture(rpcResult);
2764 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2766 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2768 return Futures.immediateFuture(rpcResult);
2772 public Future<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
2773 GetpathsegmentTopologyOperationInput input) {
2775 final String svcOperation = "getpathsegment-topology-operation";
2776 ServiceData serviceData;
2777 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2778 Properties parms = new Properties();
2780 log.info(CALLED_STR, svcOperation);
2781 // create a new response object
2782 GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
2784 if (hasInvalidService(input)) {
2785 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2786 responseBuilder.setResponseCode("404");
2787 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2788 responseBuilder.setAckFinalIndicator("Y");
2790 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2791 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2793 return Futures.immediateFuture(rpcResult);
2796 // Grab the service instance ID from the input buffer
2797 String siid = input.getServiceInformation().getServiceInstanceId();
2799 trySetSvcRequestId(input, responseBuilder);
2801 if (hasInvalidOnapModelInformation(input)) {
2802 log.debug("exiting {} because no model-uuid provided", svcOperation);
2803 responseBuilder.setResponseCode("404");
2804 responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
2805 responseBuilder.setAckFinalIndicator("Y");
2806 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2807 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2808 return Futures.immediateFuture(rpcResult);
2811 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2812 getServiceData(siid, serviceDataBuilder);
2814 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2815 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2817 // Set the serviceStatus based on input
2818 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2819 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2821 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2822 GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
2824 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2826 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2827 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2829 // Call SLI sync method
2831 ResponseObject responseObject = new ResponseObject("200", "");
2832 String ackFinal = "Y";
2833 String serviceObjectPath = null;
2834 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2836 if (respProps != null) {
2837 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2838 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2839 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2840 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2843 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2844 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2845 serviceStatusBuilder.setRpcName(svcOperation);
2847 if (failed(responseObject)) {
2848 responseBuilder.setResponseCode(responseObject.getStatusCode());
2849 responseBuilder.setResponseMessage(responseObject.getMessage());
2850 responseBuilder.setAckFinalIndicator(ackFinal);
2852 ServiceBuilder serviceBuilder = new ServiceBuilder();
2853 serviceBuilder.setServiceInstanceId(siid);
2854 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2856 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2857 } catch (Exception e) {
2858 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2860 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2862 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2863 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2865 return Futures.immediateFuture(rpcResult);
2868 // Got success from SLI
2870 serviceData = serviceDataBuilder.build();
2871 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2874 ServiceBuilder serviceBuilder = new ServiceBuilder();
2875 serviceBuilder.setServiceData(serviceData);
2876 serviceBuilder.setServiceInstanceId(siid);
2877 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2878 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2880 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2881 serviceResponseInformationBuilder.setInstanceId(siid);
2882 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2883 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2885 } catch (Exception e) {
2886 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2887 responseBuilder.setResponseCode("500");
2888 responseBuilder.setResponseMessage(e.getMessage());
2889 responseBuilder.setAckFinalIndicator("Y");
2890 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2891 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2893 return Futures.immediateFuture(rpcResult);
2897 responseBuilder.setResponseCode(responseObject.getStatusCode());
2898 responseBuilder.setAckFinalIndicator(ackFinal);
2899 trySetResponseMessage(responseBuilder, responseObject);
2900 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2901 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2903 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2904 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2906 return Futures.immediateFuture(rpcResult);
2909 private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
2910 return input == null || input.getServiceInformation() == null
2911 || input.getServiceInformation().getServiceInstanceId() == null
2912 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2915 private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
2916 GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
2917 if (input.getSdncRequestHeader() != null) {
2918 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2922 private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
2923 return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
2924 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
2927 private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
2928 ResponseObject responseObject) {
2929 if (responseObject.getMessage() != null) {
2930 if (!responseObject.getMessage().isEmpty()) {
2931 responseBuilder.setResponseMessage(responseObject.getMessage());
2937 public Future<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
2938 PolicyUpdateNotifyOperationInput input) {
2940 final String svcOperation = "policy-update-notify-operation";
2941 Properties parms = new Properties();
2943 log.info(CALLED_STR, svcOperation);
2945 // create a new response object
2946 PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
2948 // Make sure we have a valid input
2949 if (hasInvalidInput(input)) {
2950 log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
2951 responseBuilder.setErrorCode("404");
2952 responseBuilder.setErrorMsg("Invalid input, missing input data");
2953 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2954 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2955 return Futures.immediateFuture(rpcResult);
2958 log.info("Adding INPUT data for {} input: {}", svcOperation, input);
2959 PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
2960 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2962 // Call SLI sync method
2963 ResponseObject responseObject = new ResponseObject("200", "");
2964 String ackFinal = "Y";
2965 String serviceObjectPath = null;
2966 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2968 if (respProps != null) {
2969 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2970 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2971 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2972 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2975 if (failed(responseObject)) {
2976 responseBuilder.setErrorCode(responseObject.getStatusCode());
2977 responseBuilder.setErrorMsg(responseObject.getMessage());
2978 log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
2980 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2981 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2983 return Futures.immediateFuture(rpcResult);
2986 // Got success from SLI
2987 responseBuilder.setErrorCode(responseObject.getStatusCode());
2988 if (responseObject.getMessage() != null) {
2989 responseBuilder.setErrorMsg(responseObject.getMessage());
2991 log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
2992 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2993 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2995 return Futures.immediateFuture(rpcResult);
2998 private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
2999 return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3003 public Future<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3004 final PortMirrorTopologyOperationInput input) {
3006 final String svcOperation = "port-mirror-topology-operation";
3007 ServiceData serviceData = null;
3008 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3009 Properties properties = new Properties();
3011 log.info(CALLED_STR, svcOperation);
3013 // create a new response object
3014 PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3016 if (hasInvalidService(input)) {
3017 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3018 responseBuilder.setResponseCode("404");
3019 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3020 responseBuilder.setAckFinalIndicator("Y");
3021 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3022 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3024 return Futures.immediateFuture(rpcResult);
3027 if (hasInvalidConfigurationId(input)) {
3028 log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3029 responseBuilder.setResponseCode("404");
3030 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3031 responseBuilder.setAckFinalIndicator("Y");
3032 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3033 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3034 return Futures.immediateFuture(rpcResult);
3037 // Grab the service instance ID from the input buffer
3038 String siid = input.getServiceInformation().getServiceInstanceId();
3040 trySetSvcRequestId(input, responseBuilder);
3042 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3043 getServiceData(siid, serviceDataBuilder);
3045 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3046 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3048 // Set the serviceStatus based on input
3049 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3050 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3052 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3053 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3054 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3056 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3057 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3059 // Call SLI sync method
3060 ResponseObject responseObject = new ResponseObject("200", "");
3061 String ackFinal = "Y";
3062 String serviceObjectPath = null;
3063 String portMirrorObjectPath = null;
3064 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3066 if (respProps != null) {
3067 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3068 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3069 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3070 serviceObjectPath = respProps.getProperty("service-object-path");
3071 portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3074 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3075 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3076 serviceStatusBuilder.setRpcName(svcOperation);
3078 if (failed(responseObject)) {
3079 responseBuilder.setResponseCode(responseObject.getStatusCode());
3080 responseBuilder.setResponseMessage(responseObject.getMessage());
3081 responseBuilder.setAckFinalIndicator(ackFinal);
3083 ServiceBuilder serviceBuilder = new ServiceBuilder();
3084 serviceBuilder.setServiceInstanceId(siid);
3085 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3087 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3088 } catch (Exception e) {
3089 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3091 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3093 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3094 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3097 return Futures.immediateFuture(rpcResult);
3100 // Got success from SLI
3102 serviceData = serviceDataBuilder.build();
3103 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3106 ServiceBuilder serviceBuilder = new ServiceBuilder();
3107 serviceBuilder.setServiceData(serviceData);
3108 serviceBuilder.setServiceInstanceId(siid);
3109 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3110 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3112 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3113 // Only update operational tree on activate or delete
3114 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3115 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3116 log.info(UPDATING_TREE_INFO_MESSAGE);
3117 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3121 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3122 serviceResponseInformationBuilder.setInstanceId(siid);
3123 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3124 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3125 PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3126 portMirrorResponseInformationBuilder
3127 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3128 portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3129 responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3131 } catch (Exception e) {
3132 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3133 responseBuilder.setResponseCode("500");
3134 responseBuilder.setResponseMessage(e.getMessage());
3135 responseBuilder.setAckFinalIndicator("Y");
3136 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3137 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3138 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3139 return Futures.immediateFuture(rpcResult);
3143 responseBuilder.setResponseCode(responseObject.getStatusCode());
3144 responseBuilder.setAckFinalIndicator(ackFinal);
3145 trySetResponseMessage(responseBuilder, responseObject);
3146 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3147 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3149 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3150 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3152 if (ackFinal.equals("N")) {
3153 // Spawn background thread to invoke the Async DG
3154 Runnable backgroundThread = new Runnable() {
3156 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3157 processAsyncPortMirrorTopologyOperation(input);
3160 new Thread(backgroundThread).start();
3164 return Futures.immediateFuture(rpcResult);
3167 private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3168 return input == null || input.getServiceInformation() == null
3169 || input.getServiceInformation().getServiceInstanceId() == null
3170 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3173 private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3174 return input.getConfigurationInformation() == null
3175 || input.getConfigurationInformation().getConfigurationId() == null
3176 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3179 private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3180 PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3181 if (input.getSdncRequestHeader() != null) {
3182 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3186 private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3187 ResponseObject responseObject) {
3188 if (responseObject.getMessage() != null) {
3189 if (!responseObject.getMessage().isEmpty()) {
3190 responseBuilder.setResponseMessage(responseObject.getMessage());
3195 public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3196 log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3198 final String svcOperation = "port-mirror-topology-operation-async";
3199 ServiceData serviceData = null;
3200 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3201 Properties parms = new Properties();
3203 log.info(CALLED_STR, svcOperation);
3205 // Grab the service instance ID from the input buffer
3206 String siid = input.getServiceInformation().getServiceInstanceId();
3208 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3209 getServiceData(siid, serviceDataBuilder);
3211 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3212 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3214 // Set the serviceStatus based on input
3215 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3216 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3218 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3219 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3220 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3222 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3223 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3225 // Call SLI sync method
3226 ResponseObject responseObject = new ResponseObject("200", "");
3227 String ackFinal = "Y";
3228 String serviceObjectPath = null;
3229 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3231 if (respProps != null) {
3232 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3233 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3234 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3237 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3238 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3239 serviceStatusBuilder.setRpcName(svcOperation);
3241 if (failed(responseObject)) {
3242 ServiceBuilder serviceBuilder = new ServiceBuilder();
3243 serviceBuilder.setServiceInstanceId(siid);
3244 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3246 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3247 } catch (Exception e) {
3248 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3255 // Got success from SLI
3257 serviceData = serviceDataBuilder.build();
3258 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3261 ServiceBuilder serviceBuilder = new ServiceBuilder();
3262 serviceBuilder.setServiceData(serviceData);
3263 serviceBuilder.setServiceInstanceId(siid);
3264 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3265 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3267 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3268 // Only update operational tree on activate or delete
3269 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3270 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3271 log.info(UPDATING_TREE_INFO_MESSAGE);
3272 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3276 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3277 serviceResponseInformationBuilder.setInstanceId(siid);
3278 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3280 } catch (Exception e) {
3281 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3286 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3292 public Future<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(VnfGetResourceRequestInput input) {
3294 final String svcOperation = "vnf-get-resource-request";
3295 ServiceData serviceData;
3296 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3297 Properties parms = new Properties();
3299 log.info(CALLED_STR, svcOperation);
3300 // create a new response object
3301 VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3303 if (hasInvalidService(input)) {
3304 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3305 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3306 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3308 return Futures.immediateFuture(rpcResult);
3311 // Grab the service instance ID from the input buffer
3312 String siid = input.getServiceInformation().getServiceInstanceId();
3314 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3315 getServiceData(siid, serviceDataBuilder);
3317 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3318 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3320 // Set the serviceStatus based on input
3321 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3322 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3324 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3325 VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3326 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3328 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3329 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3331 // Call SLI sync method
3333 ResponseObject responseObject = new ResponseObject("200", "");
3334 String ackFinal = "Y";
3335 String serviceObjectPath = null;
3336 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3338 if (respProps != null) {
3339 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3340 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3341 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3342 serviceObjectPath = respProps.getProperty("service-object-path");
3345 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3346 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3347 serviceStatusBuilder.setRpcName(svcOperation);
3349 if (failed(responseObject)) {
3350 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3351 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3352 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3354 return Futures.immediateFuture(rpcResult);
3357 // Got success from SLI
3358 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3360 if (respProps != null) {
3361 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3364 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3365 .withResult(responseBuilder.build()).build();
3368 return Futures.immediateFuture(rpcResult);
3371 private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3372 return input == null || input.getServiceInformation() == null
3373 || input.getServiceInformation().getServiceInstanceId() == null
3374 || input.getServiceInformation().getServiceInstanceId().length() == 0;