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();
1817 String siid = input.getServiceInformation().getServiceInstanceId();
1818 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1820 // Get the service-instance service data from MD-SAL
1821 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1822 getServiceData(siid, serviceDataBuilder);
1824 trySetSvcRequestId(input, responseBuilder);
1826 ServiceData sd = serviceDataBuilder.build();
1827 if (isInvalidServiceData(sd)) {
1828 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1829 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1832 ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(input);
1833 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1835 // Call SLI sync method
1836 // Get SvcLogicService reference
1837 ResponseObject responseObject = new ResponseObject("200", "");
1838 String ackFinal = "Y";
1839 String allottedResourceId = ERROR_NETWORK_ID;
1840 String serviceObjectPath = null;
1841 String connectionAttachmentObjectPath = null;
1843 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1845 if (respProps != null) {
1846 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1847 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1848 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1849 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1850 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1851 connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
1854 if (failed(responseObject)) {
1855 responseBuilder.setResponseCode(responseObject.getStatusCode());
1856 responseBuilder.setResponseMessage(responseObject.getMessage());
1857 responseBuilder.setAckFinalIndicator(ackFinal);
1859 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1861 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1862 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1863 .withResult(responseBuilder.build())
1866 return Futures.immediateFuture(rpcResult);
1869 // Got success from SLI
1872 serviceData = serviceDataBuilder.build();
1873 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1876 ServiceBuilder serviceBuilder = new ServiceBuilder();
1877 serviceBuilder.setServiceData(serviceData);
1878 serviceBuilder.setServiceInstanceId(siid);
1879 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1880 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1882 trySaveService(input, serviceBuilder);
1884 ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
1885 connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
1886 connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
1887 responseBuilder.setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
1889 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1890 serviceResponseInformationBuilder.setInstanceId(siid);
1891 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1892 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1894 } catch (IllegalStateException e) {
1895 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1896 responseBuilder.setResponseCode("500");
1897 responseBuilder.setResponseMessage(e.getMessage());
1898 responseBuilder.setAckFinalIndicator("Y");
1899 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1901 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1902 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1903 .withResult(responseBuilder.build())
1906 return Futures.immediateFuture(rpcResult);
1910 responseBuilder.setResponseCode(responseObject.getStatusCode());
1911 responseBuilder.setAckFinalIndicator(ackFinal);
1912 trySetResponseMessage(responseBuilder, responseObject);
1913 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1914 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1916 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1917 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1918 .withResult(responseBuilder.build())
1921 return Futures.immediateFuture(rpcResult);
1925 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1926 TunnelxconnTopologyOperationInput input) {
1928 final String svcOperation = "tunnelxconn-topology-operation";
1929 Properties parms = new Properties();
1930 log.info(CALLED_STR, svcOperation);
1932 // create a new response object
1933 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1934 if (hasInvalidServiceId(input)) {
1935 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1936 responseBuilder.setResponseCode("404");
1937 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1938 responseBuilder.setAckFinalIndicator("Y");
1940 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1941 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1943 return Futures.immediateFuture(rpcResult);
1945 String siid = input.getServiceInformation().getServiceInstanceId();
1946 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1947 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1948 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1950 // Call SLI sync method
1952 ResponseObject responseObject = new ResponseObject("200", "");
1953 String ackFinal = "Y";
1954 String allottedResourceId = ERROR_NETWORK_ID;
1955 String serviceObjectPath = null;
1956 String tunnelxconnObjectPath = null;
1957 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1959 if (respProps != null) {
1960 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1961 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1962 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1963 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1964 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1965 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1968 if (failed(responseObject)) {
1969 responseBuilder.setResponseCode(responseObject.getStatusCode());
1970 responseBuilder.setResponseMessage(responseObject.getMessage());
1971 responseBuilder.setAckFinalIndicator(ackFinal);
1973 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1975 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1976 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1978 return Futures.immediateFuture(rpcResult);
1981 // Got success from SLI
1983 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1984 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1985 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1986 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1988 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1989 serviceResponseInformationBuilder.setInstanceId(siid);
1990 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1991 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1993 } catch (IllegalStateException e) {
1994 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1995 responseBuilder.setResponseCode("500");
1996 responseBuilder.setResponseMessage(e.getMessage());
1997 responseBuilder.setAckFinalIndicator("Y");
1998 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2000 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2001 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2003 return Futures.immediateFuture(rpcResult);
2007 responseBuilder.setResponseCode(responseObject.getStatusCode());
2008 responseBuilder.setAckFinalIndicator(ackFinal);
2009 trySetResponseMessage(responseBuilder, responseObject);
2010 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2011 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2013 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2014 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2016 return Futures.immediateFuture(rpcResult);
2019 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2020 ResponseObject responseObject) {
2021 if (responseObject.getMessage() != null) {
2022 responseBuilder.setResponseMessage(responseObject.getMessage());
2026 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2027 return input == null || input.getServiceInformation() == null
2028 || input.getServiceInformation().getServiceInstanceId() == null
2029 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2032 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2034 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2037 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2038 } catch (Exception e) {
2039 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2040 responseObject.setMessage(e.getMessage());
2041 responseObject.setStatusCode("500");
2044 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2045 responseObject.setStatusCode("503");
2047 } catch (Exception e) {
2048 responseObject.setMessage(e.getMessage());
2049 responseObject.setStatusCode("500");
2050 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2056 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
2057 final String svcOperation = "brg-topology-operation";
2058 Properties parms = new Properties();
2060 log.info(CALLED_STR, svcOperation);
2061 // create a new response object
2062 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2064 if (this.hasInvalidServiceId(input)) {
2066 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2067 responseBuilder.setResponseCode("404");
2068 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2069 responseBuilder.setAckFinalIndicator("Y");
2071 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2072 .withResult(responseBuilder.build()).build();
2074 return Futures.immediateFuture(rpcResult);
2077 String siid = input.getServiceInformation().getServiceInstanceId();
2079 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2080 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2081 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2083 // Call SLI sync method
2085 ResponseObject responseObject = new ResponseObject("200", "");
2086 String ackFinal = "Y";
2087 String allottedResourceId = ERROR_NETWORK_ID;
2088 String serviceObjectPath = null;
2089 String brgObjectPath = null;
2090 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2092 if (respProps != null) {
2093 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2094 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2095 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2096 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2097 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2098 brgObjectPath = respProps.getProperty("brg-object-path");
2101 if (failed(responseObject)) {
2102 responseBuilder.setResponseCode(responseObject.getStatusCode());
2103 responseBuilder.setResponseMessage(responseObject.getMessage());
2104 responseBuilder.setAckFinalIndicator(ackFinal);
2106 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2107 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2108 .withResult(responseBuilder.build()).build();
2110 return Futures.immediateFuture(rpcResult);
2113 // Got success from SLI
2116 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2117 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2118 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2119 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2121 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2122 serviceResponseInformationBuilder.setInstanceId(siid);
2123 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2124 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2126 } catch (IllegalStateException e) {
2127 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2128 responseBuilder.setResponseCode("500");
2129 responseBuilder.setResponseMessage(e.getMessage());
2130 responseBuilder.setAckFinalIndicator("Y");
2131 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2133 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2134 .withResult(responseBuilder.build()).build();
2136 return Futures.immediateFuture(rpcResult);
2140 responseBuilder.setResponseCode(responseObject.getStatusCode());
2141 responseBuilder.setAckFinalIndicator(ackFinal);
2142 trySetResponseMessage(responseBuilder, responseObject);
2143 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2144 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2146 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2147 .withResult(responseBuilder.build()).build();
2149 return Futures.immediateFuture(rpcResult);
2152 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2153 ResponseObject responseObject) {
2154 if (responseObject.getMessage() != null) {
2155 responseBuilder.setResponseMessage(responseObject.getMessage());
2159 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2160 return input == null || input.getServiceInformation() == null
2161 || input.getServiceInformation().getServiceInstanceId() == null
2162 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2165 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2166 if (respProps != null) {
2167 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2168 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2169 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2175 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2176 PreloadNetworkTopologyOperationInput input) {
2178 final String svcOperation = "preload-network-topology-operation";
2179 PreloadData preloadData;
2180 Properties properties = new Properties();
2182 log.info(CALLED_STR, svcOperation);
2183 // create a new response object
2184 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2186 if (hasInvalidPreloadNetwork(input)) {
2187 log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2188 responseBuilder.setResponseCode("403");
2189 responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2190 responseBuilder.setAckFinalIndicator("Y");
2192 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2193 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2195 return Futures.immediateFuture(rpcResult);
2198 // Grab the preload ID from the input buffer
2199 String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2201 String preloadType = "network";
2203 trySetSvcRequestId(input, responseBuilder);
2205 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2206 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2208 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2209 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2212 // setup a preload-data object builder
2213 // ACTION preload-network-topology-operation
2215 // uses sdnc-request-header;
2216 // uses request-information;
2217 // uses preload-network-topology-information;
2219 // uses preload-topology-response-body;
2221 // container preload-data
2222 // uses preload-network-topology-information;
2223 // uses preload-oper-status;
2225 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2226 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2228 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2229 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2230 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2232 // Call SLI sync method
2233 ResponseObject responseObject = new ResponseObject("200", "");
2234 String ackFinal = "Y";
2235 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2237 if (respProps != null) {
2238 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2239 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2240 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2243 if (failed(responseObject)) {
2244 responseBuilder.setResponseCode(responseObject.getStatusCode());
2245 responseBuilder.setResponseMessage(responseObject.getMessage());
2246 responseBuilder.setAckFinalIndicator(ackFinal);
2247 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2248 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2249 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2250 return Futures.immediateFuture(rpcResult);
2253 // Got success from SLI
2255 preloadData = preloadDataBuilder.build();
2256 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2258 // preload-list object
2259 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2260 preloadListBuilder.setPreloadId(preloadId);
2261 preloadListBuilder.setPreloadType(preloadType);
2262 preloadListBuilder.setPreloadData(preloadData);
2264 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2265 log.info(UPDATING_TREE_INFO_MESSAGE);
2266 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2268 tryDeletePreload(input, preloadListBuilder);
2269 } catch (Exception e) {
2270 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2271 responseBuilder.setResponseCode("500");
2272 responseBuilder.setResponseMessage(e.getMessage());
2273 responseBuilder.setAckFinalIndicator("Y");
2274 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2275 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2276 .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2277 return Futures.immediateFuture(rpcResult);
2281 responseBuilder.setResponseCode(responseObject.getStatusCode());
2282 responseBuilder.setAckFinalIndicator(ackFinal);
2283 trySetResponseMessage(responseBuilder, responseObject);
2284 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2285 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2287 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2288 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2289 return Futures.immediateFuture(rpcResult);
2292 private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2293 return input == null || input.getPreloadNetworkTopologyInformation() == null
2294 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2297 private boolean hasInvalidPreloadId(String preloadId) {
2298 return preloadId == null || preloadId.length() == 0;
2301 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2302 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2303 if (input.getSdncRequestHeader() != null) {
2304 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2308 private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2309 ResponseObject responseObject) {
2311 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2313 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2314 } catch (Exception e) {
2315 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2316 responseObject.setMessage(e.getMessage());
2317 responseObject.setStatusCode("500");
2320 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2321 responseObject.setStatusCode("503");
2323 } catch (Exception e) {
2324 responseObject.setMessage(e.getMessage());
2325 responseObject.setStatusCode("500");
2326 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2332 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2333 ResponseObject responseObject) {
2334 if (responseObject.getMessage() != null) {
2335 if (!responseObject.getMessage().isEmpty()) {
2336 responseBuilder.setResponseMessage(responseObject.getMessage());
2341 private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2342 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2343 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2344 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2345 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2350 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2351 PreloadVfModuleTopologyOperationInput input) {
2353 final String svcOperation = "preload-vf-module-topology-operation";
2354 PreloadData preloadData;
2355 Properties properties = new Properties();
2357 log.info(CALLED_STR, svcOperation);
2358 // create a new response object
2359 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2361 if (hasInvalidPreloadVfModule(input)) {
2363 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2365 responseBuilder.setResponseCode("403");
2366 responseBuilder.setResponseMessage(
2367 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2368 responseBuilder.setAckFinalIndicator("Y");
2370 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2371 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2373 return Futures.immediateFuture(rpcResult);
2376 // Grab the preload ID from the input buffer
2377 String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2378 .getVfModuleTopologyIdentifier().getVfModuleName();
2379 String preloadType = "vf-module";
2381 trySetSvcRequestId(input, responseBuilder);
2383 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2384 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2386 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2387 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2390 // setup a preload-data object builder
2391 // ACTION preload-vf-module-topology-operation
2393 // uses sdnc-request-header;
2394 // uses request-information;
2395 // uses preload-vnf-topology-information;
2397 // uses preload-topology-response-body;
2399 // container preload-data
2400 // uses preload-vf-module-topology-information;
2401 // uses preload-oper-status;
2403 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2404 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2406 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2407 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2408 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2410 // Call SLI sync method
2411 ResponseObject responseObject = new ResponseObject("200", "");
2412 String ackFinal = "Y";
2413 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2415 if (respProps != null) {
2416 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2417 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2418 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2421 if (failed(responseObject)) {
2422 responseBuilder.setResponseCode(responseObject.getStatusCode());
2423 responseBuilder.setResponseMessage(responseObject.getMessage());
2424 responseBuilder.setAckFinalIndicator(ackFinal);
2425 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2426 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2427 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2428 return Futures.immediateFuture(rpcResult);
2431 // Got success from SLI
2433 preloadData = preloadDataBuilder.build();
2434 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2436 // preload-list object
2437 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2438 preloadListBuilder.setPreloadId(preloadId);
2439 preloadListBuilder.setPreloadType(preloadType);
2440 preloadListBuilder.setPreloadData(preloadData);
2442 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2443 log.info(UPDATING_TREE_INFO_MESSAGE);
2444 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2446 tryDeletePreload(input, preloadListBuilder);
2448 } catch (Exception e) {
2449 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2450 responseBuilder.setResponseCode("500");
2451 responseBuilder.setResponseMessage(e.getMessage());
2452 responseBuilder.setAckFinalIndicator("Y");
2453 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2454 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2455 .<PreloadVfModuleTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2456 return Futures.immediateFuture(rpcResult);
2460 responseBuilder.setResponseCode(responseObject.getStatusCode());
2461 responseBuilder.setAckFinalIndicator(ackFinal);
2462 trySetResponseMessage(responseBuilder, responseObject);
2463 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2464 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2466 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2467 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2468 return Futures.immediateFuture(rpcResult);
2471 private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
2472 return input == null || input.getPreloadVfModuleTopologyInformation() == null
2473 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
2474 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2475 .getVfModuleTopologyIdentifier() == null
2476 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
2477 .getVfModuleName() == null;
2480 private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
2481 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
2482 if (input.getSdncRequestHeader() != null) {
2483 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2487 private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
2488 ResponseObject responseObject) {
2489 if (responseObject.getMessage() != null) {
2490 if (!responseObject.getMessage().isEmpty()) {
2491 responseBuilder.setResponseMessage(responseObject.getMessage());
2496 private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2497 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2498 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2499 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2500 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2505 public Future<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
2506 GenericConfigurationTopologyOperationInput input) {
2508 final String svcOperation = "generic-configuration-topology-operation";
2509 ServiceData serviceData;
2510 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2511 Properties parms = new Properties();
2513 log.info(CALLED_STR, svcOperation);
2514 // create a new response object
2515 GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
2517 if (hasInvalidService(input)) {
2518 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2519 responseBuilder.setResponseCode("404");
2520 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2521 responseBuilder.setAckFinalIndicator("Y");
2523 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2524 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2527 return Futures.immediateFuture(rpcResult);
2530 // Grab the service instance ID from the input buffer
2531 String siid = input.getServiceInformation().getServiceInstanceId();
2533 trySetSvcRequestId(input, responseBuilder);
2535 if (hasInvalidConfigurationIdOrType(input)) {
2536 log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
2537 responseBuilder.setResponseCode("404");
2538 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
2539 responseBuilder.setAckFinalIndicator("Y");
2540 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2541 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2543 return Futures.immediateFuture(rpcResult);
2546 // Grab the configuration ID from the input buffer
2547 String configId = input.getConfigurationInformation().getConfigurationId();
2549 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2550 getServiceData(siid, serviceDataBuilder);
2552 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2553 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2555 // Set the serviceStatus based on input
2556 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2557 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2559 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2560 GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
2562 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2564 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2565 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2567 // Call SLI sync method
2569 ResponseObject responseObject = new ResponseObject("200", "");
2570 String ackFinal = "Y";
2571 String serviceObjectPath = "";
2572 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2574 if (respProps != null) {
2575 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2576 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2577 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2578 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2581 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2582 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2583 serviceStatusBuilder.setRpcName(svcOperation);
2585 if (failed(responseObject)) {
2586 responseBuilder.setResponseCode(responseObject.getStatusCode());
2587 responseBuilder.setResponseMessage(responseObject.getMessage());
2588 responseBuilder.setAckFinalIndicator(ackFinal);
2590 ServiceBuilder serviceBuilder = new ServiceBuilder();
2591 serviceBuilder.setServiceInstanceId(siid);
2592 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2594 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2595 } catch (Exception e) {
2596 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2598 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2600 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2601 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2604 return Futures.immediateFuture(rpcResult);
2607 // Got success from SLI
2609 serviceData = serviceDataBuilder.build();
2612 ServiceBuilder serviceBuilder = new ServiceBuilder();
2613 serviceBuilder.setServiceData(serviceData);
2614 serviceBuilder.setServiceInstanceId(siid);
2615 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2616 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2618 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2619 serviceResponseInformationBuilder.setInstanceId(siid);
2620 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2621 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2622 GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
2623 gcResponseInformationBuilder.setInstanceId(configId);
2624 responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
2626 } catch (Exception e) {
2627 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2628 responseBuilder.setResponseCode("500");
2629 responseBuilder.setResponseMessage(e.getMessage());
2630 responseBuilder.setAckFinalIndicator("Y");
2631 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2632 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2635 return Futures.immediateFuture(rpcResult);
2639 responseBuilder.setResponseCode(responseObject.getStatusCode());
2640 responseBuilder.setAckFinalIndicator(ackFinal);
2641 trySetResponseMessage(responseBuilder, responseObject);
2642 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2643 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2645 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2646 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2648 return Futures.immediateFuture(rpcResult);
2651 private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
2652 return input == null || input.getServiceInformation() == null
2653 || input.getServiceInformation().getServiceInstanceId() == null
2654 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2657 private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
2658 GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
2659 if (input.getSdncRequestHeader() != null) {
2660 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2664 private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
2665 return input.getConfigurationInformation() == null
2666 || input.getConfigurationInformation().getConfigurationId() == null
2667 || input.getConfigurationInformation().getConfigurationType() == null;
2670 private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
2671 ResponseObject responseObject) {
2672 if (responseObject.getMessage() != null) {
2673 if (!responseObject.getMessage().isEmpty()) {
2674 responseBuilder.setResponseMessage(responseObject.getMessage());
2680 public Future<RpcResult<Void>> genericConfigurationNotification(GenericConfigurationNotificationInput input) {
2682 final String svcOperation = "generic-configuration-notification";
2683 ServiceData serviceData;
2684 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2685 Properties parms = new Properties();
2687 log.info(CALLED_STR, svcOperation);
2689 // Grab the service instance ID from the input buffer
2690 String siid = input.getServiceInformation().getServiceInstanceId();
2692 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2693 getServiceData(siid, serviceDataBuilder);
2695 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2696 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2698 // Set the serviceStatus based on input
2699 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2700 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2702 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2703 GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
2705 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2707 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2708 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2710 // Call SLI sync method
2712 ResponseObject responseObject = new ResponseObject("200", "");
2713 String ackFinal = "Y";
2714 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2716 if (respProps != null) {
2717 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2718 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2719 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2722 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2723 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2724 serviceStatusBuilder.setRpcName(svcOperation);
2726 if (failed(responseObject)) {
2727 ServiceBuilder serviceBuilder = new ServiceBuilder();
2728 serviceBuilder.setServiceInstanceId(siid);
2729 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2731 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2732 } catch (Exception e) {
2733 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2736 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2738 return Futures.immediateFuture(rpcResult);
2741 // Got success from SLI
2743 serviceData = serviceDataBuilder.build();
2746 ServiceBuilder serviceBuilder = new ServiceBuilder();
2747 serviceBuilder.setServiceData(serviceData);
2748 serviceBuilder.setServiceInstanceId(siid);
2749 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2750 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2752 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2753 serviceResponseInformationBuilder.setInstanceId(siid);
2755 } catch (Exception e) {
2756 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2757 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2759 return Futures.immediateFuture(rpcResult);
2763 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2765 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2767 return Futures.immediateFuture(rpcResult);
2771 public Future<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
2772 GetpathsegmentTopologyOperationInput input) {
2774 final String svcOperation = "getpathsegment-topology-operation";
2775 ServiceData serviceData;
2776 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2777 Properties parms = new Properties();
2779 log.info(CALLED_STR, svcOperation);
2780 // create a new response object
2781 GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
2783 if (hasInvalidService(input)) {
2784 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2785 responseBuilder.setResponseCode("404");
2786 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2787 responseBuilder.setAckFinalIndicator("Y");
2789 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2790 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2792 return Futures.immediateFuture(rpcResult);
2795 // Grab the service instance ID from the input buffer
2796 String siid = input.getServiceInformation().getServiceInstanceId();
2798 trySetSvcRequestId(input, responseBuilder);
2800 if (hasInvalidOnapModelInformation(input)) {
2801 log.debug("exiting {} because no model-uuid provided", svcOperation);
2802 responseBuilder.setResponseCode("404");
2803 responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
2804 responseBuilder.setAckFinalIndicator("Y");
2805 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2806 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2807 return Futures.immediateFuture(rpcResult);
2810 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2811 getServiceData(siid, serviceDataBuilder);
2813 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2814 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2816 // Set the serviceStatus based on input
2817 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2818 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2820 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2821 GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
2823 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2825 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2826 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2828 // Call SLI sync method
2830 ResponseObject responseObject = new ResponseObject("200", "");
2831 String ackFinal = "Y";
2832 String serviceObjectPath = null;
2833 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2835 if (respProps != null) {
2836 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2837 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2838 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2839 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2842 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2843 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2844 serviceStatusBuilder.setRpcName(svcOperation);
2846 if (failed(responseObject)) {
2847 responseBuilder.setResponseCode(responseObject.getStatusCode());
2848 responseBuilder.setResponseMessage(responseObject.getMessage());
2849 responseBuilder.setAckFinalIndicator(ackFinal);
2851 ServiceBuilder serviceBuilder = new ServiceBuilder();
2852 serviceBuilder.setServiceInstanceId(siid);
2853 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2855 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2856 } catch (Exception e) {
2857 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2859 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2861 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2862 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2864 return Futures.immediateFuture(rpcResult);
2867 // Got success from SLI
2869 serviceData = serviceDataBuilder.build();
2870 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2873 ServiceBuilder serviceBuilder = new ServiceBuilder();
2874 serviceBuilder.setServiceData(serviceData);
2875 serviceBuilder.setServiceInstanceId(siid);
2876 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2877 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2879 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2880 serviceResponseInformationBuilder.setInstanceId(siid);
2881 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2882 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2884 } catch (Exception e) {
2885 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2886 responseBuilder.setResponseCode("500");
2887 responseBuilder.setResponseMessage(e.getMessage());
2888 responseBuilder.setAckFinalIndicator("Y");
2889 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2890 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2892 return Futures.immediateFuture(rpcResult);
2896 responseBuilder.setResponseCode(responseObject.getStatusCode());
2897 responseBuilder.setAckFinalIndicator(ackFinal);
2898 trySetResponseMessage(responseBuilder, responseObject);
2899 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2900 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2902 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2903 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2905 return Futures.immediateFuture(rpcResult);
2908 private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
2909 return input == null || input.getServiceInformation() == null
2910 || input.getServiceInformation().getServiceInstanceId() == null
2911 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2914 private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
2915 GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
2916 if (input.getSdncRequestHeader() != null) {
2917 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2921 private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
2922 return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
2923 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
2926 private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
2927 ResponseObject responseObject) {
2928 if (responseObject.getMessage() != null) {
2929 if (!responseObject.getMessage().isEmpty()) {
2930 responseBuilder.setResponseMessage(responseObject.getMessage());
2936 public Future<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
2937 PolicyUpdateNotifyOperationInput input) {
2939 final String svcOperation = "policy-update-notify-operation";
2940 Properties parms = new Properties();
2942 log.info(CALLED_STR, svcOperation);
2944 // create a new response object
2945 PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
2947 // Make sure we have a valid input
2948 if (hasInvalidInput(input)) {
2949 log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
2950 responseBuilder.setErrorCode("404");
2951 responseBuilder.setErrorMsg("Invalid input, missing input data");
2952 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2953 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2954 return Futures.immediateFuture(rpcResult);
2957 log.info("Adding INPUT data for {} input: {}", svcOperation, input);
2958 PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
2959 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2961 // Call SLI sync method
2962 ResponseObject responseObject = new ResponseObject("200", "");
2963 String ackFinal = "Y";
2964 String serviceObjectPath = null;
2965 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2967 if (respProps != null) {
2968 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2969 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2970 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2971 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2974 if (failed(responseObject)) {
2975 responseBuilder.setErrorCode(responseObject.getStatusCode());
2976 responseBuilder.setErrorMsg(responseObject.getMessage());
2977 log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
2979 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2980 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2982 return Futures.immediateFuture(rpcResult);
2985 // Got success from SLI
2986 responseBuilder.setErrorCode(responseObject.getStatusCode());
2987 if (responseObject.getMessage() != null) {
2988 responseBuilder.setErrorMsg(responseObject.getMessage());
2990 log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
2991 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2992 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2994 return Futures.immediateFuture(rpcResult);
2997 private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
2998 return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3002 public Future<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3003 final PortMirrorTopologyOperationInput input) {
3005 final String svcOperation = "port-mirror-topology-operation";
3006 ServiceData serviceData = null;
3007 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3008 Properties properties = new Properties();
3010 log.info(CALLED_STR, svcOperation);
3012 // create a new response object
3013 PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3015 if (hasInvalidService(input)) {
3016 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3017 responseBuilder.setResponseCode("404");
3018 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3019 responseBuilder.setAckFinalIndicator("Y");
3020 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3021 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3023 return Futures.immediateFuture(rpcResult);
3026 if (hasInvalidConfigurationId(input)) {
3027 log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3028 responseBuilder.setResponseCode("404");
3029 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3030 responseBuilder.setAckFinalIndicator("Y");
3031 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3032 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3033 return Futures.immediateFuture(rpcResult);
3036 // Grab the service instance ID from the input buffer
3037 String siid = input.getServiceInformation().getServiceInstanceId();
3039 trySetSvcRequestId(input, responseBuilder);
3041 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3042 getServiceData(siid, serviceDataBuilder);
3044 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3045 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3047 // Set the serviceStatus based on input
3048 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3049 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3051 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3052 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3053 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3055 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3056 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3058 // Call SLI sync method
3059 ResponseObject responseObject = new ResponseObject("200", "");
3060 String ackFinal = "Y";
3061 String serviceObjectPath = null;
3062 String portMirrorObjectPath = null;
3063 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3065 if (respProps != null) {
3066 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3067 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3068 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3069 serviceObjectPath = respProps.getProperty("service-object-path");
3070 portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3073 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3074 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3075 serviceStatusBuilder.setRpcName(svcOperation);
3077 if (failed(responseObject)) {
3078 responseBuilder.setResponseCode(responseObject.getStatusCode());
3079 responseBuilder.setResponseMessage(responseObject.getMessage());
3080 responseBuilder.setAckFinalIndicator(ackFinal);
3082 ServiceBuilder serviceBuilder = new ServiceBuilder();
3083 serviceBuilder.setServiceInstanceId(siid);
3084 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3086 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3087 } catch (Exception e) {
3088 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3090 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3092 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3093 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3096 return Futures.immediateFuture(rpcResult);
3099 // Got success from SLI
3101 serviceData = serviceDataBuilder.build();
3102 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3105 ServiceBuilder serviceBuilder = new ServiceBuilder();
3106 serviceBuilder.setServiceData(serviceData);
3107 serviceBuilder.setServiceInstanceId(siid);
3108 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3109 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3111 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3112 // Only update operational tree on activate or delete
3113 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3114 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3115 log.info(UPDATING_TREE_INFO_MESSAGE);
3116 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3120 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3121 serviceResponseInformationBuilder.setInstanceId(siid);
3122 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3123 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3124 PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3125 portMirrorResponseInformationBuilder
3126 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3127 portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3128 responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3130 } catch (Exception e) {
3131 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3132 responseBuilder.setResponseCode("500");
3133 responseBuilder.setResponseMessage(e.getMessage());
3134 responseBuilder.setAckFinalIndicator("Y");
3135 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3136 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3137 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3138 return Futures.immediateFuture(rpcResult);
3142 responseBuilder.setResponseCode(responseObject.getStatusCode());
3143 responseBuilder.setAckFinalIndicator(ackFinal);
3144 trySetResponseMessage(responseBuilder, responseObject);
3145 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3146 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3148 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3149 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3151 if (ackFinal.equals("N")) {
3152 // Spawn background thread to invoke the Async DG
3153 Runnable backgroundThread = new Runnable() {
3155 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3156 processAsyncPortMirrorTopologyOperation(input);
3159 new Thread(backgroundThread).start();
3163 return Futures.immediateFuture(rpcResult);
3166 private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3167 return input == null || input.getServiceInformation() == null
3168 || input.getServiceInformation().getServiceInstanceId() == null
3169 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3172 private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3173 return input.getConfigurationInformation() == null
3174 || input.getConfigurationInformation().getConfigurationId() == null
3175 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3178 private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3179 PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3180 if (input.getSdncRequestHeader() != null) {
3181 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3185 private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3186 ResponseObject responseObject) {
3187 if (responseObject.getMessage() != null) {
3188 if (!responseObject.getMessage().isEmpty()) {
3189 responseBuilder.setResponseMessage(responseObject.getMessage());
3194 public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3195 log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3197 final String svcOperation = "port-mirror-topology-operation-async";
3198 ServiceData serviceData = null;
3199 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3200 Properties parms = new Properties();
3202 log.info(CALLED_STR, svcOperation);
3204 // Grab the service instance ID from the input buffer
3205 String siid = input.getServiceInformation().getServiceInstanceId();
3207 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3208 getServiceData(siid, serviceDataBuilder);
3210 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3211 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3213 // Set the serviceStatus based on input
3214 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3215 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3217 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3218 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3219 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3221 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3222 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3224 // Call SLI sync method
3225 ResponseObject responseObject = new ResponseObject("200", "");
3226 String ackFinal = "Y";
3227 String serviceObjectPath = null;
3228 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3230 if (respProps != null) {
3231 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3232 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3233 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3236 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3237 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3238 serviceStatusBuilder.setRpcName(svcOperation);
3240 if (failed(responseObject)) {
3241 ServiceBuilder serviceBuilder = new ServiceBuilder();
3242 serviceBuilder.setServiceInstanceId(siid);
3243 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3245 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3246 } catch (Exception e) {
3247 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3254 // Got success from SLI
3256 serviceData = serviceDataBuilder.build();
3257 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3260 ServiceBuilder serviceBuilder = new ServiceBuilder();
3261 serviceBuilder.setServiceData(serviceData);
3262 serviceBuilder.setServiceInstanceId(siid);
3263 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3264 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3266 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3267 // Only update operational tree on activate or delete
3268 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3269 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3270 log.info(UPDATING_TREE_INFO_MESSAGE);
3271 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3275 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3276 serviceResponseInformationBuilder.setInstanceId(siid);
3277 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3279 } catch (Exception e) {
3280 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3285 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3291 public Future<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(VnfGetResourceRequestInput input) {
3293 final String svcOperation = "vnf-get-resource-request";
3294 ServiceData serviceData;
3295 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3296 Properties parms = new Properties();
3298 log.info(CALLED_STR, svcOperation);
3299 // create a new response object
3300 VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3302 if (hasInvalidService(input)) {
3303 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3304 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3305 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3307 return Futures.immediateFuture(rpcResult);
3310 // Grab the service instance ID from the input buffer
3311 String siid = input.getServiceInformation().getServiceInstanceId();
3313 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3314 getServiceData(siid, serviceDataBuilder);
3316 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3317 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3319 // Set the serviceStatus based on input
3320 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3321 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3323 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3324 VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3325 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3327 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3328 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3330 // Call SLI sync method
3332 ResponseObject responseObject = new ResponseObject("200", "");
3333 String ackFinal = "Y";
3334 String serviceObjectPath = null;
3335 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3337 if (respProps != null) {
3338 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3339 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3340 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3341 serviceObjectPath = respProps.getProperty("service-object-path");
3344 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3345 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3346 serviceStatusBuilder.setRpcName(svcOperation);
3348 if (failed(responseObject)) {
3349 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3350 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3351 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3353 return Futures.immediateFuture(rpcResult);
3356 // Got success from SLI
3357 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3359 if (respProps != null) {
3360 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3363 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3364 .withResult(responseBuilder.build()).build();
3367 return Futures.immediateFuture(rpcResult);
3370 private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3371 return input == null || input.getServiceInformation() == null
3372 || input.getServiceInformation().getServiceInstanceId() == null
3373 || input.getServiceInformation().getServiceInstanceId().length() == 0;