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");
873 vnfId = respProps.getProperty("vnfId");
875 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
876 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
879 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
880 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
881 serviceStatusBuilder.setRpcName(svcOperation);
883 if (failed(responseObject)) {
884 responseBuilder.setResponseCode(responseObject.getStatusCode());
885 responseBuilder.setResponseMessage(responseObject.getMessage());
886 responseBuilder.setAckFinalIndicator(ackFinal);
888 ServiceBuilder serviceBuilder = new ServiceBuilder();
889 serviceBuilder.setServiceInstanceId(siid);
890 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
892 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
893 trySaveService(input, serviceBuilder);
894 } catch (Exception e) {
895 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
897 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
899 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
900 .withResult(responseBuilder.build()).build();
903 return Futures.immediateFuture(rpcResult);
906 // Got success from SLI
908 serviceData = serviceDataBuilder.build();
909 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
912 ServiceBuilder serviceBuilder = new ServiceBuilder();
913 serviceBuilder.setServiceData(serviceData);
914 serviceBuilder.setServiceInstanceId(siid);
915 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
916 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
918 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
919 // Only update operational tree on Assign
920 log.info(UPDATING_TREE_INFO_MESSAGE);
921 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
924 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
925 serviceResponseInformationBuilder.setInstanceId(siid);
926 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
927 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
929 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
930 vnfResponseInformationBuilder.setInstanceId(vnfId);
931 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
932 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
934 } catch (Exception e) {
935 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
936 responseBuilder.setResponseCode("500");
937 responseBuilder.setResponseMessage(e.getMessage());
938 responseBuilder.setAckFinalIndicator("Y");
939 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
941 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
942 .withResult(responseBuilder.build()).build();
944 return Futures.immediateFuture(rpcResult);
948 responseBuilder.setResponseCode(responseObject.getStatusCode());
949 responseBuilder.setAckFinalIndicator(ackFinal);
950 trySetResponseMessage(responseBuilder, responseObject);
951 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
952 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
954 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
955 .withResult(responseBuilder.build()).build();
958 return Futures.immediateFuture(rpcResult);
961 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
962 ResponseObject responseObject) {
963 if (responseObject.getMessage() != null) {
964 responseBuilder.setResponseMessage(responseObject.getMessage());
968 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
969 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
970 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
972 // Only update operational tree on activate or delete
973 log.info(UPDATING_TREE_INFO_MESSAGE);
974 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
978 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
979 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
980 || input.getVnfInformation().getVnfId().length() == 0;
983 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
984 return input == null || input.getServiceInformation() == null
985 || input.getServiceInformation().getServiceInstanceId() == null
986 || input.getServiceInformation().getServiceInstanceId().length() == 0;
989 private void trySetSvcRequestId(VnfTopologyOperationInput input,
990 VnfTopologyOperationOutputBuilder responseBuilder) {
991 if (input.getSdncRequestHeader() != null) {
992 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
996 private boolean isValidRequest(VnfTopologyOperationInput input) {
997 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1001 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1002 VfModuleTopologyOperationInput input) {
1004 final String svcOperation = "vf-module-topology-operation";
1005 ServiceData serviceData;
1006 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1007 Properties parms = new Properties();
1009 log.info(CALLED_STR, svcOperation);
1010 // create a new response object
1011 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1013 if (hasInvalidServiceId(input)) {
1014 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1015 responseBuilder.setResponseCode("403");
1016 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1017 responseBuilder.setAckFinalIndicator("Y");
1019 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1020 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1023 return Futures.immediateFuture(rpcResult);
1026 if (hasInvalidVnfId(input)) {
1027 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1028 responseBuilder.setResponseCode("403");
1029 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1030 responseBuilder.setAckFinalIndicator("Y");
1031 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1032 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1033 return Futures.immediateFuture(rpcResult);
1036 if (hasInvalidVfModuleId(input)) {
1037 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1038 responseBuilder.setResponseCode("403");
1039 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1040 responseBuilder.setAckFinalIndicator("Y");
1042 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1043 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1045 return Futures.immediateFuture(rpcResult);
1048 // Grab the service instance ID from the input buffer
1049 String siid = input.getServiceInformation().getServiceInstanceId();
1050 String vnfId = input.getVnfInformation().getVnfId();
1051 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1053 trySetSvcRequestId(input, responseBuilder);
1055 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1056 getServiceData(siid, serviceDataBuilder);
1058 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1059 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1061 // Set the serviceStatus based on input
1062 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1063 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1066 // setup a service-data object builder
1067 // ACTION vnf-topology-operation
1069 // USES sdnc-request-header;
1070 // USES request-information;
1071 // USES service-information;
1072 // USES vnf-request-information
1074 // USES vnf-topology-response-body;
1075 // USES vnf-information
1076 // USES service-information
1078 // container service-data
1079 // uses vnf-configuration-information;
1080 // uses oper-status;
1082 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1083 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1084 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1086 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1087 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1089 // Call SLI sync method
1091 ResponseObject responseObject = new ResponseObject("200", "");
1092 String ackFinal = "Y";
1093 String serviceObjectPath = null;
1094 String vnfObjectPath = null;
1095 String vfModuleObjectPath = null;
1096 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1098 if (respProps != null) {
1099 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1100 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1101 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1102 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1103 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1104 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1107 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1108 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1109 serviceStatusBuilder.setRpcName(svcOperation);
1111 if (failed(responseObject)) {
1112 responseBuilder.setResponseCode(responseObject.getStatusCode());
1113 responseBuilder.setResponseMessage(responseObject.getMessage());
1114 responseBuilder.setAckFinalIndicator(ackFinal);
1116 ServiceBuilder serviceBuilder = new ServiceBuilder();
1117 serviceBuilder.setServiceInstanceId(siid);
1118 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1120 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1121 } catch (Exception e) {
1122 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1124 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1126 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1127 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1130 return Futures.immediateFuture(rpcResult);
1133 // Got success from SLI
1135 serviceData = serviceDataBuilder.build();
1136 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1139 ServiceBuilder serviceBuilder = new ServiceBuilder();
1140 serviceBuilder.setServiceData(serviceData);
1141 serviceBuilder.setServiceInstanceId(siid);
1142 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1143 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1145 trySaveService(input, serviceBuilder);
1147 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1148 serviceResponseInformationBuilder.setInstanceId(siid);
1149 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1150 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1152 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1153 vnfResponseInformationBuilder.setInstanceId(vnfId);
1154 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1155 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1157 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1158 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1159 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1160 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1162 } catch (Exception e) {
1163 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1164 responseBuilder.setResponseCode("500");
1165 responseBuilder.setResponseMessage(e.getMessage());
1166 responseBuilder.setAckFinalIndicator("Y");
1167 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1169 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1170 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1172 return Futures.immediateFuture(rpcResult);
1176 responseBuilder.setResponseCode(responseObject.getStatusCode());
1177 responseBuilder.setAckFinalIndicator(ackFinal);
1178 trySetResponseMessage(responseBuilder, responseObject);
1179 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1180 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1182 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1183 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1186 return Futures.immediateFuture(rpcResult);
1189 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1190 ResponseObject responseObject) {
1191 if (responseObject.getMessage() != null) {
1192 responseBuilder.setResponseMessage(responseObject.getMessage());
1196 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1197 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1198 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1199 // Only update operational tree on activate or delete
1201 log.info(UPDATING_TREE_INFO_MESSAGE);
1202 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1206 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1207 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1208 if (input.getSdncRequestHeader() != null) {
1209 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1213 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1214 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1215 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1218 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1219 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1220 || input.getVnfInformation().getVnfId().length() == 0;
1223 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1224 return input == null || input.getServiceInformation() == null
1225 || input.getServiceInformation().getServiceInstanceId() == null
1226 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1229 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1230 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1234 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1235 NetworkTopologyOperationInput input) {
1237 final String svcOperation = "network-topology-operation";
1238 ServiceData serviceData;
1239 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1240 Properties parms = new Properties();
1242 log.info(CALLED_STR, svcOperation);
1243 // create a new response object
1244 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1246 if (hasInvalidServiceId(input)) {
1247 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1248 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1251 String siid = input.getServiceInformation().getServiceInstanceId();
1253 // Get the service-instance service data from MD-SAL
1254 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1255 getServiceData(siid, serviceDataBuilder);
1257 this.trySetSvcRequestId(input, responseBuilder);
1259 ServiceData sd = serviceDataBuilder.build();
1260 if (isInvalidServiceData(sd)) {
1261 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1262 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1265 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1266 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1267 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1269 // Call SLI sync method
1271 ResponseObject responseObject = new ResponseObject("200", "");
1272 String ackFinal = "Y";
1273 String networkId = ERROR_NETWORK_ID;
1274 String serviceObjectPath = null;
1275 String networkObjectPath = null;
1276 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1278 if (respProps != null) {
1279 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1280 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1281 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1282 networkId = respProps.getProperty("networkId");
1283 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1284 networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1287 if (failed(responseObject)) {
1288 responseBuilder.setResponseCode(responseObject.getStatusCode());
1289 responseBuilder.setResponseMessage(responseObject.getMessage());
1290 responseBuilder.setAckFinalIndicator(ackFinal);
1292 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1294 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1295 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1297 return Futures.immediateFuture(rpcResult);
1300 // Got success from SLI
1303 serviceData = serviceDataBuilder.build();
1304 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1307 ServiceBuilder serviceBuilder = new ServiceBuilder();
1308 serviceBuilder.setServiceData(serviceData);
1309 serviceBuilder.setServiceInstanceId(siid);
1310 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1311 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1313 trySaveService(input, serviceBuilder);
1315 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1316 networkResponseInformationBuilder.setInstanceId(networkId);
1317 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1318 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1320 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1321 serviceResponseInformationBuilder.setInstanceId(siid);
1322 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1323 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1325 } catch (IllegalStateException e) {
1326 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1327 responseBuilder.setResponseCode("500");
1328 responseBuilder.setResponseMessage(e.getMessage());
1329 responseBuilder.setAckFinalIndicator("Y");
1330 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1332 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1333 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1335 return Futures.immediateFuture(rpcResult);
1339 responseBuilder.setResponseCode(responseObject.getStatusCode());
1340 responseBuilder.setAckFinalIndicator(ackFinal);
1341 trySetResponseMessage(responseBuilder, responseObject);
1342 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1343 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1345 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1346 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1348 return Futures.immediateFuture(rpcResult);
1351 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1352 ResponseObject responseObject) {
1353 if (responseObject.getMessage() != null) {
1354 responseBuilder.setResponseMessage(responseObject.getMessage());
1358 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1359 NetworkTopologyOperationOutputBuilder responseBuilder) {
1360 if (input.getSdncRequestHeader() != null) {
1361 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1365 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1366 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1367 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1368 // Only update operational tree on Activate
1369 log.info(UPDATING_TREE_INFO_MESSAGE);
1370 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1374 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1375 return input == null || input.getServiceInformation() == null
1376 || input.getServiceInformation().getServiceInstanceId() == null
1377 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1380 private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1381 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1383 responseBuilder.setResponseCode("404");
1384 responseBuilder.setResponseMessage(responseMessage);
1385 responseBuilder.setAckFinalIndicator("Y");
1387 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1388 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1390 return Futures.immediateFuture(rpcResult);
1393 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1394 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1398 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1399 ContrailRouteTopologyOperationInput input) {
1401 final String svcOperation = "contrail-route-topology-operation";
1402 ServiceData serviceData;
1403 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1404 Properties properties = new Properties();
1406 log.info(CALLED_STR, svcOperation);
1407 // create a new response object
1408 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1410 if (hasInvalidServiceId(input)) {
1411 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1412 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1415 String siid = input.getServiceInformation().getServiceInstanceId();
1417 // Get the service-instance service data from MD-SAL
1418 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1419 getServiceData(siid, serviceDataBuilder);
1421 trySetSvcRequestId(input, responseBuilder);
1423 ServiceData sd = serviceDataBuilder.build();
1424 if (isInvalidServiceData(sd)) {
1425 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1426 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1429 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1430 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1431 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1433 // Call SLI sync method
1435 ResponseObject responseObject = new ResponseObject("200", "");
1436 String ackFinal = "Y";
1437 String allottedResourceId = ERROR_NETWORK_ID;
1438 String serviceObjectPath = null;
1439 String contrailRouteObjectPath = null;
1440 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1442 if (respProps != null) {
1443 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1444 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1445 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1446 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1447 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1448 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1451 if (failed(responseObject)) {
1452 responseBuilder.setResponseCode(responseObject.getStatusCode());
1453 responseBuilder.setResponseMessage(responseObject.getMessage());
1454 responseBuilder.setAckFinalIndicator(ackFinal);
1455 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1457 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1458 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1460 return Futures.immediateFuture(rpcResult);
1463 // Got success from SLI
1465 serviceData = serviceDataBuilder.build();
1466 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1469 ServiceBuilder serviceBuilder = new ServiceBuilder();
1470 serviceBuilder.setServiceData(serviceData);
1471 serviceBuilder.setServiceInstanceId(siid);
1472 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1473 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1475 trySaveService(input, serviceBuilder);
1477 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1478 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1479 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1480 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1482 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1483 serviceResponseInformationBuilder.setInstanceId(siid);
1484 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1485 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1487 } catch (IllegalStateException e) {
1488 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1489 responseBuilder.setResponseCode("500");
1490 responseBuilder.setResponseMessage(e.getMessage());
1491 responseBuilder.setAckFinalIndicator("Y");
1492 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1494 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1495 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1497 return Futures.immediateFuture(rpcResult);
1501 responseBuilder.setResponseCode(responseObject.getStatusCode());
1502 responseBuilder.setAckFinalIndicator(ackFinal);
1503 trySetResponseMessage(responseBuilder, responseObject);
1504 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1505 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1507 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1508 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1510 return Futures.immediateFuture(rpcResult);
1513 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1514 ResponseObject responseObject) {
1515 if (responseObject.getMessage() != null) {
1516 responseBuilder.setResponseMessage(responseObject.getMessage());
1520 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1521 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1522 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1523 // Only update operational tree on activate or delete
1524 log.info(UPDATING_TREE_INFO_MESSAGE);
1525 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1529 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1530 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1531 if (input.getSdncRequestHeader() != null) {
1532 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1536 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1537 return input == null || input.getServiceInformation() == null
1538 || input.getServiceInformation().getServiceInstanceId() == null
1539 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1542 private Future<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
1543 ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1544 responseBuilder.setResponseCode("404");
1545 responseBuilder.setResponseMessage(responseMessage);
1546 responseBuilder.setAckFinalIndicator("Y");
1548 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1549 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1551 return Futures.immediateFuture(rpcResult);
1554 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1555 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1559 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1560 SecurityZoneTopologyOperationInput input) {
1562 final String svcOperation = "security-zone-topology-operation";
1563 ServiceData serviceData;
1564 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1565 Properties parms = new Properties();
1567 log.info(CALLED_STR, svcOperation);
1568 // create a new response object
1569 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1571 if (this.hasInvalidServiceId(input)) {
1572 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1573 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1576 String siid = input.getServiceInformation().getServiceInstanceId();
1578 // Get the service-instance service data from MD-SAL
1579 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1580 getServiceData(siid, serviceDataBuilder);
1581 trySetSvcRequestId(input, responseBuilder);
1583 ServiceData sd = serviceDataBuilder.build();
1584 if (isInvalidServiceData(sd)) {
1585 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1586 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1589 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1590 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1591 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1593 // Call SLI sync method
1595 Properties respProps = null;
1597 ResponseObject responseObject = new ResponseObject("200", "");
1598 String ackFinal = "Y";
1599 String allottedResourceId = ERROR_NETWORK_ID;
1600 String serviceObjectPath = null;
1601 String securityZoneObjectPath = null;
1604 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1607 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1608 } catch (Exception e) {
1609 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1610 responseObject.setMessage(e.getMessage());
1611 responseObject.setStatusCode("500");
1614 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1615 responseObject.setStatusCode("503");
1617 } catch (Exception e) {
1618 responseObject.setStatusCode("500");
1619 responseObject.setMessage(e.getMessage());
1620 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1623 if (respProps != null) {
1624 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1625 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1626 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1627 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1628 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1629 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1632 if (failed(responseObject)) {
1633 responseBuilder.setResponseCode(responseObject.getStatusCode());
1634 responseBuilder.setResponseMessage(responseObject.getMessage());
1635 responseBuilder.setAckFinalIndicator(ackFinal);
1636 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1638 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1639 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1641 return Futures.immediateFuture(rpcResult);
1644 // Got success from SLI
1647 serviceData = serviceDataBuilder.build();
1648 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1651 ServiceBuilder serviceBuilder = new ServiceBuilder();
1652 serviceBuilder.setServiceData(serviceData);
1653 serviceBuilder.setServiceInstanceId(siid);
1654 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1655 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1657 trySaveService(input, serviceBuilder);
1659 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1660 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1661 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1662 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1664 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1665 serviceResponseInformationBuilder.setInstanceId(siid);
1666 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1667 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1669 } catch (IllegalStateException e) {
1670 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1671 responseBuilder.setResponseCode("500");
1672 responseBuilder.setResponseMessage(e.getMessage());
1673 responseBuilder.setAckFinalIndicator("Y");
1674 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1676 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1677 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1679 return Futures.immediateFuture(rpcResult);
1683 responseBuilder.setResponseCode(responseObject.getStatusCode());
1684 responseBuilder.setAckFinalIndicator(ackFinal);
1685 trySetResponseMessage(responseBuilder, responseObject);
1686 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1687 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1689 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1690 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1692 return Futures.immediateFuture(rpcResult);
1695 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1696 ResponseObject responseObject) {
1697 if (responseObject.getMessage() != null) {
1698 responseBuilder.setResponseMessage(responseObject.getMessage());
1702 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1703 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1704 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1705 // Only update operational tree on activate or delete
1706 log.info(UPDATING_TREE_INFO_MESSAGE);
1707 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1711 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1712 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1713 if (input.getSdncRequestHeader() != null) {
1714 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1718 private boolean isInvalidServiceData(ServiceData sd) {
1719 return sd == null || sd.getServiceLevelOperStatus() == null;
1722 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1723 return input == null || input.getServiceInformation() == null
1724 || input.getServiceInformation().getServiceInstanceId() == null
1725 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1728 private Future<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
1729 SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1731 responseBuilder.setResponseCode("404");
1732 responseBuilder.setResponseMessage(responseMessage);
1733 responseBuilder.setAckFinalIndicator("Y");
1735 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1736 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1738 return Futures.immediateFuture(rpcResult);
1741 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1742 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1746 private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
1747 return input == null || input.getServiceInformation() == null
1748 || input.getServiceInformation().getServiceInstanceId() == null
1749 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1752 private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
1753 ResponseObject error) {
1754 if (!error.getMessage().isEmpty()) {
1755 responseBuilder.setResponseMessage(error.getMessage());
1759 private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
1760 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
1761 if (input.getSdncRequestHeader() != null) {
1762 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1766 private Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
1767 buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1769 responseBuilder.setResponseCode("404");
1770 responseBuilder.setResponseMessage(responseMessage);
1771 responseBuilder.setAckFinalIndicator("Y");
1773 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1774 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1775 .withResult(responseBuilder.build())
1778 return Futures.immediateFuture(rpcResult);
1781 private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1782 if (isValidRequest(input) &&
1783 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1784 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1785 // Only update operational tree on activate or delete
1786 log.info(UPDATING_TREE_INFO_MESSAGE);
1787 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1791 private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
1792 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1796 public Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(ConnectionAttachmentTopologyOperationInput input) {
1797 final String svcOperation = "connection-attachment-topology-operation";
1798 Properties parms = new Properties();
1799 log.info(CALLED_STR, svcOperation);
1801 // create a new response object
1802 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
1803 if (hasInvalidServiceId(input)) {
1804 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1805 responseBuilder.setResponseCode("404");
1806 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1807 responseBuilder.setAckFinalIndicator("Y");
1809 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1810 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1811 .withResult(responseBuilder.build())
1814 return Futures.immediateFuture(rpcResult);
1817 ServiceData serviceData;
1818 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1820 String siid = input.getServiceInformation().getServiceInstanceId();
1821 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1823 // Get the service-instance service data from MD-SAL
1824 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1825 getServiceData(siid, serviceDataBuilder);
1827 trySetSvcRequestId(input, responseBuilder);
1829 ServiceData sd = serviceDataBuilder.build();
1830 if (isInvalidServiceData(sd)) {
1831 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1832 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1835 ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(input);
1836 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1838 // Call SLI sync method
1839 // Get SvcLogicService reference
1840 ResponseObject responseObject = new ResponseObject("200", "");
1841 String ackFinal = "Y";
1842 String allottedResourceId = ERROR_NETWORK_ID;
1843 String serviceObjectPath = null;
1844 String connectionAttachmentObjectPath = null;
1846 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1848 if (respProps != null) {
1849 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1850 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1851 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1852 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1853 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1854 connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
1857 if (failed(responseObject)) {
1858 responseBuilder.setResponseCode(responseObject.getStatusCode());
1859 responseBuilder.setResponseMessage(responseObject.getMessage());
1860 responseBuilder.setAckFinalIndicator(ackFinal);
1862 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1864 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1865 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1866 .withResult(responseBuilder.build())
1869 return Futures.immediateFuture(rpcResult);
1872 // Got success from SLI
1875 serviceData = serviceDataBuilder.build();
1876 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1879 ServiceBuilder serviceBuilder = new ServiceBuilder();
1880 serviceBuilder.setServiceData(serviceData);
1881 serviceBuilder.setServiceInstanceId(siid);
1882 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1883 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1885 trySaveService(input, serviceBuilder);
1887 ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
1888 connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
1889 connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
1890 responseBuilder.setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
1892 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1893 serviceResponseInformationBuilder.setInstanceId(siid);
1894 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1895 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1897 } catch (IllegalStateException e) {
1898 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1899 responseBuilder.setResponseCode("500");
1900 responseBuilder.setResponseMessage(e.getMessage());
1901 responseBuilder.setAckFinalIndicator("Y");
1902 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1904 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1905 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1906 .withResult(responseBuilder.build())
1909 return Futures.immediateFuture(rpcResult);
1913 responseBuilder.setResponseCode(responseObject.getStatusCode());
1914 responseBuilder.setAckFinalIndicator(ackFinal);
1915 trySetResponseMessage(responseBuilder, responseObject);
1916 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1917 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1919 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1920 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1921 .withResult(responseBuilder.build())
1924 return Futures.immediateFuture(rpcResult);
1928 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1929 TunnelxconnTopologyOperationInput input) {
1931 final String svcOperation = "tunnelxconn-topology-operation";
1932 Properties parms = new Properties();
1933 log.info(CALLED_STR, svcOperation);
1935 // create a new response object
1936 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1937 if (hasInvalidServiceId(input)) {
1938 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1939 responseBuilder.setResponseCode("404");
1940 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1941 responseBuilder.setAckFinalIndicator("Y");
1943 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1944 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1946 return Futures.immediateFuture(rpcResult);
1948 String siid = input.getServiceInformation().getServiceInstanceId();
1949 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1950 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1951 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1953 // Call SLI sync method
1955 ResponseObject responseObject = new ResponseObject("200", "");
1956 String ackFinal = "Y";
1957 String allottedResourceId = ERROR_NETWORK_ID;
1958 String serviceObjectPath = null;
1959 String tunnelxconnObjectPath = null;
1960 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1962 if (respProps != null) {
1963 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1964 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1965 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1966 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1967 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1968 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1971 if (failed(responseObject)) {
1972 responseBuilder.setResponseCode(responseObject.getStatusCode());
1973 responseBuilder.setResponseMessage(responseObject.getMessage());
1974 responseBuilder.setAckFinalIndicator(ackFinal);
1976 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1978 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1979 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1981 return Futures.immediateFuture(rpcResult);
1984 // Got success from SLI
1986 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1987 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1988 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1989 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1991 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1992 serviceResponseInformationBuilder.setInstanceId(siid);
1993 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1994 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1996 } catch (IllegalStateException e) {
1997 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1998 responseBuilder.setResponseCode("500");
1999 responseBuilder.setResponseMessage(e.getMessage());
2000 responseBuilder.setAckFinalIndicator("Y");
2001 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2003 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2004 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2006 return Futures.immediateFuture(rpcResult);
2010 responseBuilder.setResponseCode(responseObject.getStatusCode());
2011 responseBuilder.setAckFinalIndicator(ackFinal);
2012 trySetResponseMessage(responseBuilder, responseObject);
2013 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2014 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2016 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2017 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2019 return Futures.immediateFuture(rpcResult);
2022 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2023 ResponseObject responseObject) {
2024 if (responseObject.getMessage() != null) {
2025 responseBuilder.setResponseMessage(responseObject.getMessage());
2029 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2030 return input == null || input.getServiceInformation() == null
2031 || input.getServiceInformation().getServiceInstanceId() == null
2032 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2035 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2037 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2040 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2041 } catch (Exception e) {
2042 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2043 responseObject.setMessage(e.getMessage());
2044 responseObject.setStatusCode("500");
2047 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2048 responseObject.setStatusCode("503");
2050 } catch (Exception e) {
2051 responseObject.setMessage(e.getMessage());
2052 responseObject.setStatusCode("500");
2053 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2059 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
2060 final String svcOperation = "brg-topology-operation";
2061 Properties parms = new Properties();
2063 log.info(CALLED_STR, svcOperation);
2064 // create a new response object
2065 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2067 if (this.hasInvalidServiceId(input)) {
2069 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2070 responseBuilder.setResponseCode("404");
2071 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2072 responseBuilder.setAckFinalIndicator("Y");
2074 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2075 .withResult(responseBuilder.build()).build();
2077 return Futures.immediateFuture(rpcResult);
2080 String siid = input.getServiceInformation().getServiceInstanceId();
2082 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2083 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2084 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2086 // Call SLI sync method
2088 ResponseObject responseObject = new ResponseObject("200", "");
2089 String ackFinal = "Y";
2090 String allottedResourceId = ERROR_NETWORK_ID;
2091 String serviceObjectPath = null;
2092 String brgObjectPath = null;
2093 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2095 if (respProps != null) {
2096 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2097 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2098 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2099 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2100 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2101 brgObjectPath = respProps.getProperty("brg-object-path");
2104 if (failed(responseObject)) {
2105 responseBuilder.setResponseCode(responseObject.getStatusCode());
2106 responseBuilder.setResponseMessage(responseObject.getMessage());
2107 responseBuilder.setAckFinalIndicator(ackFinal);
2109 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2110 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2111 .withResult(responseBuilder.build()).build();
2113 return Futures.immediateFuture(rpcResult);
2116 // Got success from SLI
2119 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2120 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2121 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2122 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2124 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2125 serviceResponseInformationBuilder.setInstanceId(siid);
2126 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2127 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2129 } catch (IllegalStateException e) {
2130 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2131 responseBuilder.setResponseCode("500");
2132 responseBuilder.setResponseMessage(e.getMessage());
2133 responseBuilder.setAckFinalIndicator("Y");
2134 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2136 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2137 .withResult(responseBuilder.build()).build();
2139 return Futures.immediateFuture(rpcResult);
2143 responseBuilder.setResponseCode(responseObject.getStatusCode());
2144 responseBuilder.setAckFinalIndicator(ackFinal);
2145 trySetResponseMessage(responseBuilder, responseObject);
2146 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2147 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2149 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2150 .withResult(responseBuilder.build()).build();
2152 return Futures.immediateFuture(rpcResult);
2155 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2156 ResponseObject responseObject) {
2157 if (responseObject.getMessage() != null) {
2158 responseBuilder.setResponseMessage(responseObject.getMessage());
2162 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2163 return input == null || input.getServiceInformation() == null
2164 || input.getServiceInformation().getServiceInstanceId() == null
2165 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2168 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2169 if (respProps != null) {
2170 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2171 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2172 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2178 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2179 PreloadNetworkTopologyOperationInput input) {
2181 final String svcOperation = "preload-network-topology-operation";
2182 PreloadData preloadData;
2183 Properties properties = new Properties();
2185 log.info(CALLED_STR, svcOperation);
2186 // create a new response object
2187 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2189 if (hasInvalidPreloadNetwork(input)) {
2190 log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2191 responseBuilder.setResponseCode("403");
2192 responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2193 responseBuilder.setAckFinalIndicator("Y");
2195 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2196 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2198 return Futures.immediateFuture(rpcResult);
2201 // Grab the preload ID from the input buffer
2202 String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2204 String preloadType = "network";
2206 trySetSvcRequestId(input, responseBuilder);
2208 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2209 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2211 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2212 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2215 // setup a preload-data object builder
2216 // ACTION preload-network-topology-operation
2218 // uses sdnc-request-header;
2219 // uses request-information;
2220 // uses preload-network-topology-information;
2222 // uses preload-topology-response-body;
2224 // container preload-data
2225 // uses preload-network-topology-information;
2226 // uses preload-oper-status;
2228 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2229 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2231 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2232 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2233 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2235 // Call SLI sync method
2236 ResponseObject responseObject = new ResponseObject("200", "");
2237 String ackFinal = "Y";
2238 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2240 if (respProps != null) {
2241 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2242 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2243 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2246 if (failed(responseObject)) {
2247 responseBuilder.setResponseCode(responseObject.getStatusCode());
2248 responseBuilder.setResponseMessage(responseObject.getMessage());
2249 responseBuilder.setAckFinalIndicator(ackFinal);
2250 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2251 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2252 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2253 return Futures.immediateFuture(rpcResult);
2256 // Got success from SLI
2258 preloadData = preloadDataBuilder.build();
2259 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2261 // preload-list object
2262 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2263 preloadListBuilder.setPreloadId(preloadId);
2264 preloadListBuilder.setPreloadType(preloadType);
2265 preloadListBuilder.setPreloadData(preloadData);
2267 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2268 log.info(UPDATING_TREE_INFO_MESSAGE);
2269 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2271 tryDeletePreload(input, preloadListBuilder);
2272 } catch (Exception e) {
2273 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2274 responseBuilder.setResponseCode("500");
2275 responseBuilder.setResponseMessage(e.getMessage());
2276 responseBuilder.setAckFinalIndicator("Y");
2277 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2278 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2279 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2280 return Futures.immediateFuture(rpcResult);
2284 responseBuilder.setResponseCode(responseObject.getStatusCode());
2285 responseBuilder.setAckFinalIndicator(ackFinal);
2286 trySetResponseMessage(responseBuilder, responseObject);
2287 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2288 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2290 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2291 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2292 return Futures.immediateFuture(rpcResult);
2295 private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2296 return input == null || input.getPreloadNetworkTopologyInformation() == null
2297 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2300 private boolean hasInvalidPreloadId(String preloadId) {
2301 return preloadId == null || preloadId.length() == 0;
2304 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2305 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2306 if (input.getSdncRequestHeader() != null) {
2307 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2311 private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2312 ResponseObject responseObject) {
2314 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2316 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2317 } catch (Exception e) {
2318 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2319 responseObject.setMessage(e.getMessage());
2320 responseObject.setStatusCode("500");
2323 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2324 responseObject.setStatusCode("503");
2326 } catch (Exception e) {
2327 responseObject.setMessage(e.getMessage());
2328 responseObject.setStatusCode("500");
2329 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2335 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2336 ResponseObject responseObject) {
2337 if (responseObject.getMessage() != null) {
2338 if (!responseObject.getMessage().isEmpty()) {
2339 responseBuilder.setResponseMessage(responseObject.getMessage());
2344 private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2345 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2346 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2347 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2348 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2353 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2354 PreloadVfModuleTopologyOperationInput input) {
2356 final String svcOperation = "preload-vf-module-topology-operation";
2357 PreloadData preloadData;
2358 Properties properties = new Properties();
2360 log.info(CALLED_STR, svcOperation);
2361 // create a new response object
2362 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2364 if (hasInvalidPreloadVfModule(input)) {
2366 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2368 responseBuilder.setResponseCode("403");
2369 responseBuilder.setResponseMessage(
2370 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2371 responseBuilder.setAckFinalIndicator("Y");
2373 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2374 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2376 return Futures.immediateFuture(rpcResult);
2379 // Grab the preload ID from the input buffer
2380 String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2381 .getVfModuleTopologyIdentifier().getVfModuleName();
2382 String preloadType = "vf-module";
2384 trySetSvcRequestId(input, responseBuilder);
2386 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2387 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2389 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2390 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2393 // setup a preload-data object builder
2394 // ACTION preload-vf-module-topology-operation
2396 // uses sdnc-request-header;
2397 // uses request-information;
2398 // uses preload-vnf-topology-information;
2400 // uses preload-topology-response-body;
2402 // container preload-data
2403 // uses preload-vf-module-topology-information;
2404 // uses preload-oper-status;
2406 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2407 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2409 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2410 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2411 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2413 // Call SLI sync method
2414 ResponseObject responseObject = new ResponseObject("200", "");
2415 String ackFinal = "Y";
2416 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2418 if (respProps != null) {
2419 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2420 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2421 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2424 if (failed(responseObject)) {
2425 responseBuilder.setResponseCode(responseObject.getStatusCode());
2426 responseBuilder.setResponseMessage(responseObject.getMessage());
2427 responseBuilder.setAckFinalIndicator(ackFinal);
2428 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2429 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2430 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2431 return Futures.immediateFuture(rpcResult);
2434 // Got success from SLI
2436 preloadData = preloadDataBuilder.build();
2437 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2439 // preload-list object
2440 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2441 preloadListBuilder.setPreloadId(preloadId);
2442 preloadListBuilder.setPreloadType(preloadType);
2443 preloadListBuilder.setPreloadData(preloadData);
2445 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2446 log.info(UPDATING_TREE_INFO_MESSAGE);
2447 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2449 tryDeletePreload(input, preloadListBuilder);
2451 } catch (Exception e) {
2452 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2453 responseBuilder.setResponseCode("500");
2454 responseBuilder.setResponseMessage(e.getMessage());
2455 responseBuilder.setAckFinalIndicator("Y");
2456 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2457 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2458 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2459 return Futures.immediateFuture(rpcResult);
2463 responseBuilder.setResponseCode(responseObject.getStatusCode());
2464 responseBuilder.setAckFinalIndicator(ackFinal);
2465 trySetResponseMessage(responseBuilder, responseObject);
2466 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2467 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2469 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2470 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2471 return Futures.immediateFuture(rpcResult);
2474 private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
2475 return input == null || input.getPreloadVfModuleTopologyInformation() == null
2476 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
2477 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2478 .getVfModuleTopologyIdentifier() == null
2479 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
2480 .getVfModuleName() == null;
2483 private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
2484 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
2485 if (input.getSdncRequestHeader() != null) {
2486 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2490 private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
2491 ResponseObject responseObject) {
2492 if (responseObject.getMessage() != null) {
2493 if (!responseObject.getMessage().isEmpty()) {
2494 responseBuilder.setResponseMessage(responseObject.getMessage());
2499 private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2500 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2501 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2502 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2503 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2508 public Future<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
2509 GenericConfigurationTopologyOperationInput input) {
2511 final String svcOperation = "generic-configuration-topology-operation";
2512 ServiceData serviceData;
2513 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2514 Properties parms = new Properties();
2516 log.info(CALLED_STR, svcOperation);
2517 // create a new response object
2518 GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
2520 if (hasInvalidService(input)) {
2521 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2522 responseBuilder.setResponseCode("404");
2523 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2524 responseBuilder.setAckFinalIndicator("Y");
2526 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2527 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2530 return Futures.immediateFuture(rpcResult);
2533 // Grab the service instance ID from the input buffer
2534 String siid = input.getServiceInformation().getServiceInstanceId();
2536 trySetSvcRequestId(input, responseBuilder);
2538 if (hasInvalidConfigurationIdOrType(input)) {
2539 log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
2540 responseBuilder.setResponseCode("404");
2541 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
2542 responseBuilder.setAckFinalIndicator("Y");
2543 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2544 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2546 return Futures.immediateFuture(rpcResult);
2549 // Grab the configuration ID from the input buffer
2550 String configId = input.getConfigurationInformation().getConfigurationId();
2552 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2553 getServiceData(siid, serviceDataBuilder);
2555 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2556 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2558 // Set the serviceStatus based on input
2559 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2560 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2562 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2563 GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
2565 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2567 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2568 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2570 // Call SLI sync method
2572 ResponseObject responseObject = new ResponseObject("200", "");
2573 String ackFinal = "Y";
2574 String serviceObjectPath = "";
2575 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2577 if (respProps != null) {
2578 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2579 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2580 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2581 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2584 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2585 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2586 serviceStatusBuilder.setRpcName(svcOperation);
2588 if (failed(responseObject)) {
2589 responseBuilder.setResponseCode(responseObject.getStatusCode());
2590 responseBuilder.setResponseMessage(responseObject.getMessage());
2591 responseBuilder.setAckFinalIndicator(ackFinal);
2593 ServiceBuilder serviceBuilder = new ServiceBuilder();
2594 serviceBuilder.setServiceInstanceId(siid);
2595 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2597 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2598 } catch (Exception e) {
2599 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2601 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2603 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2604 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2607 return Futures.immediateFuture(rpcResult);
2610 // Got success from SLI
2612 serviceData = serviceDataBuilder.build();
2615 ServiceBuilder serviceBuilder = new ServiceBuilder();
2616 serviceBuilder.setServiceData(serviceData);
2617 serviceBuilder.setServiceInstanceId(siid);
2618 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2619 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2621 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2622 serviceResponseInformationBuilder.setInstanceId(siid);
2623 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2624 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2625 GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
2626 gcResponseInformationBuilder.setInstanceId(configId);
2627 responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
2629 } catch (Exception e) {
2630 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2631 responseBuilder.setResponseCode("500");
2632 responseBuilder.setResponseMessage(e.getMessage());
2633 responseBuilder.setAckFinalIndicator("Y");
2634 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2635 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2638 return Futures.immediateFuture(rpcResult);
2642 responseBuilder.setResponseCode(responseObject.getStatusCode());
2643 responseBuilder.setAckFinalIndicator(ackFinal);
2644 trySetResponseMessage(responseBuilder, responseObject);
2645 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2646 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2648 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2649 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2651 return Futures.immediateFuture(rpcResult);
2654 private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
2655 return input == null || input.getServiceInformation() == null
2656 || input.getServiceInformation().getServiceInstanceId() == null
2657 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2660 private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
2661 GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
2662 if (input.getSdncRequestHeader() != null) {
2663 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2667 private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
2668 return input.getConfigurationInformation() == null
2669 || input.getConfigurationInformation().getConfigurationId() == null
2670 || input.getConfigurationInformation().getConfigurationType() == null;
2673 private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
2674 ResponseObject responseObject) {
2675 if (responseObject.getMessage() != null) {
2676 if (!responseObject.getMessage().isEmpty()) {
2677 responseBuilder.setResponseMessage(responseObject.getMessage());
2683 public Future<RpcResult<Void>> genericConfigurationNotification(GenericConfigurationNotificationInput input) {
2685 final String svcOperation = "generic-configuration-notification";
2686 ServiceData serviceData;
2687 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2688 Properties parms = new Properties();
2690 log.info(CALLED_STR, svcOperation);
2692 // Grab the service instance ID from the input buffer
2693 String siid = input.getServiceInformation().getServiceInstanceId();
2695 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2696 getServiceData(siid, serviceDataBuilder);
2698 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2699 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2701 // Set the serviceStatus based on input
2702 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2703 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2705 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2706 GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
2708 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2710 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2711 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2713 // Call SLI sync method
2715 ResponseObject responseObject = new ResponseObject("200", "");
2716 String ackFinal = "Y";
2717 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2719 if (respProps != null) {
2720 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2721 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2722 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2725 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2726 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2727 serviceStatusBuilder.setRpcName(svcOperation);
2729 if (failed(responseObject)) {
2730 ServiceBuilder serviceBuilder = new ServiceBuilder();
2731 serviceBuilder.setServiceInstanceId(siid);
2732 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2734 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2735 } catch (Exception e) {
2736 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2739 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2741 return Futures.immediateFuture(rpcResult);
2744 // Got success from SLI
2746 serviceData = serviceDataBuilder.build();
2749 ServiceBuilder serviceBuilder = new ServiceBuilder();
2750 serviceBuilder.setServiceData(serviceData);
2751 serviceBuilder.setServiceInstanceId(siid);
2752 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2753 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2755 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2756 serviceResponseInformationBuilder.setInstanceId(siid);
2758 } catch (Exception e) {
2759 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2760 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2762 return Futures.immediateFuture(rpcResult);
2766 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2768 RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2770 return Futures.immediateFuture(rpcResult);
2774 public Future<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
2775 GetpathsegmentTopologyOperationInput input) {
2777 final String svcOperation = "getpathsegment-topology-operation";
2778 ServiceData serviceData;
2779 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2780 Properties parms = new Properties();
2782 log.info(CALLED_STR, svcOperation);
2783 // create a new response object
2784 GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
2786 if (hasInvalidService(input)) {
2787 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2788 responseBuilder.setResponseCode("404");
2789 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2790 responseBuilder.setAckFinalIndicator("Y");
2792 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2793 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2795 return Futures.immediateFuture(rpcResult);
2798 // Grab the service instance ID from the input buffer
2799 String siid = input.getServiceInformation().getServiceInstanceId();
2801 trySetSvcRequestId(input, responseBuilder);
2803 if (hasInvalidOnapModelInformation(input)) {
2804 log.debug("exiting {} because no model-uuid provided", svcOperation);
2805 responseBuilder.setResponseCode("404");
2806 responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
2807 responseBuilder.setAckFinalIndicator("Y");
2808 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2809 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2810 return Futures.immediateFuture(rpcResult);
2813 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2814 getServiceData(siid, serviceDataBuilder);
2816 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2817 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2819 // Set the serviceStatus based on input
2820 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2821 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2823 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2824 GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
2826 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2828 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2829 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2831 // Call SLI sync method
2833 ResponseObject responseObject = new ResponseObject("200", "");
2834 String ackFinal = "Y";
2835 String serviceObjectPath = null;
2836 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2838 if (respProps != null) {
2839 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2840 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2841 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2842 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2845 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2846 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2847 serviceStatusBuilder.setRpcName(svcOperation);
2849 if (failed(responseObject)) {
2850 responseBuilder.setResponseCode(responseObject.getStatusCode());
2851 responseBuilder.setResponseMessage(responseObject.getMessage());
2852 responseBuilder.setAckFinalIndicator(ackFinal);
2854 ServiceBuilder serviceBuilder = new ServiceBuilder();
2855 serviceBuilder.setServiceInstanceId(siid);
2856 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2858 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2859 } catch (Exception e) {
2860 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2862 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2864 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2865 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2867 return Futures.immediateFuture(rpcResult);
2870 // Got success from SLI
2872 serviceData = serviceDataBuilder.build();
2873 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2876 ServiceBuilder serviceBuilder = new ServiceBuilder();
2877 serviceBuilder.setServiceData(serviceData);
2878 serviceBuilder.setServiceInstanceId(siid);
2879 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2880 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2882 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2883 serviceResponseInformationBuilder.setInstanceId(siid);
2884 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2885 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2887 } catch (Exception e) {
2888 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2889 responseBuilder.setResponseCode("500");
2890 responseBuilder.setResponseMessage(e.getMessage());
2891 responseBuilder.setAckFinalIndicator("Y");
2892 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2893 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2895 return Futures.immediateFuture(rpcResult);
2899 responseBuilder.setResponseCode(responseObject.getStatusCode());
2900 responseBuilder.setAckFinalIndicator(ackFinal);
2901 trySetResponseMessage(responseBuilder, responseObject);
2902 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2903 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2905 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2906 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2908 return Futures.immediateFuture(rpcResult);
2911 private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
2912 return input == null || input.getServiceInformation() == null
2913 || input.getServiceInformation().getServiceInstanceId() == null
2914 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2917 private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
2918 GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
2919 if (input.getSdncRequestHeader() != null) {
2920 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2924 private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
2925 return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
2926 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
2929 private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
2930 ResponseObject responseObject) {
2931 if (responseObject.getMessage() != null) {
2932 if (!responseObject.getMessage().isEmpty()) {
2933 responseBuilder.setResponseMessage(responseObject.getMessage());
2939 public Future<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
2940 PolicyUpdateNotifyOperationInput input) {
2942 final String svcOperation = "policy-update-notify-operation";
2943 Properties parms = new Properties();
2945 log.info(CALLED_STR, svcOperation);
2947 // create a new response object
2948 PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
2950 // Make sure we have a valid input
2951 if (hasInvalidInput(input)) {
2952 log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
2953 responseBuilder.setErrorCode("404");
2954 responseBuilder.setErrorMsg("Invalid input, missing input data");
2955 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2956 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2957 return Futures.immediateFuture(rpcResult);
2960 log.info("Adding INPUT data for {} input: {}", svcOperation, input);
2961 PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
2962 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2964 // Call SLI sync method
2965 ResponseObject responseObject = new ResponseObject("200", "");
2966 String ackFinal = "Y";
2967 String serviceObjectPath = null;
2968 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2970 if (respProps != null) {
2971 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2972 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2973 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2974 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2977 if (failed(responseObject)) {
2978 responseBuilder.setErrorCode(responseObject.getStatusCode());
2979 responseBuilder.setErrorMsg(responseObject.getMessage());
2980 log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
2982 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2983 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2985 return Futures.immediateFuture(rpcResult);
2988 // Got success from SLI
2989 responseBuilder.setErrorCode(responseObject.getStatusCode());
2990 if (responseObject.getMessage() != null) {
2991 responseBuilder.setErrorMsg(responseObject.getMessage());
2993 log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
2994 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2995 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2997 return Futures.immediateFuture(rpcResult);
3000 private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
3001 return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3005 public Future<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3006 final PortMirrorTopologyOperationInput input) {
3008 final String svcOperation = "port-mirror-topology-operation";
3009 ServiceData serviceData = null;
3010 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3011 Properties properties = new Properties();
3013 log.info(CALLED_STR, svcOperation);
3015 // create a new response object
3016 PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3018 if (hasInvalidService(input)) {
3019 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3020 responseBuilder.setResponseCode("404");
3021 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3022 responseBuilder.setAckFinalIndicator("Y");
3023 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3024 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3026 return Futures.immediateFuture(rpcResult);
3029 if (hasInvalidConfigurationId(input)) {
3030 log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3031 responseBuilder.setResponseCode("404");
3032 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3033 responseBuilder.setAckFinalIndicator("Y");
3034 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3035 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3036 return Futures.immediateFuture(rpcResult);
3039 // Grab the service instance ID from the input buffer
3040 String siid = input.getServiceInformation().getServiceInstanceId();
3042 trySetSvcRequestId(input, responseBuilder);
3044 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3045 getServiceData(siid, serviceDataBuilder);
3047 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3048 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3050 // Set the serviceStatus based on input
3051 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3052 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3054 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3055 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3056 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3058 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3059 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3061 // Call SLI sync method
3062 ResponseObject responseObject = new ResponseObject("200", "");
3063 String ackFinal = "Y";
3064 String serviceObjectPath = null;
3065 String portMirrorObjectPath = null;
3066 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3068 if (respProps != null) {
3069 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3070 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3071 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3072 serviceObjectPath = respProps.getProperty("service-object-path");
3073 portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3076 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3077 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3078 serviceStatusBuilder.setRpcName(svcOperation);
3080 if (failed(responseObject)) {
3081 responseBuilder.setResponseCode(responseObject.getStatusCode());
3082 responseBuilder.setResponseMessage(responseObject.getMessage());
3083 responseBuilder.setAckFinalIndicator(ackFinal);
3085 ServiceBuilder serviceBuilder = new ServiceBuilder();
3086 serviceBuilder.setServiceInstanceId(siid);
3087 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3089 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3090 } catch (Exception e) {
3091 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3093 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3095 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3096 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3099 return Futures.immediateFuture(rpcResult);
3102 // Got success from SLI
3104 serviceData = serviceDataBuilder.build();
3105 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3108 ServiceBuilder serviceBuilder = new ServiceBuilder();
3109 serviceBuilder.setServiceData(serviceData);
3110 serviceBuilder.setServiceInstanceId(siid);
3111 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3112 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3114 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3115 // Only update operational tree on activate or delete
3116 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3117 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3118 log.info(UPDATING_TREE_INFO_MESSAGE);
3119 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3123 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3124 serviceResponseInformationBuilder.setInstanceId(siid);
3125 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3126 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3127 PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3128 portMirrorResponseInformationBuilder
3129 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3130 portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3131 responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3133 } catch (Exception e) {
3134 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3135 responseBuilder.setResponseCode("500");
3136 responseBuilder.setResponseMessage(e.getMessage());
3137 responseBuilder.setAckFinalIndicator("Y");
3138 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3139 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3140 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3141 return Futures.immediateFuture(rpcResult);
3145 responseBuilder.setResponseCode(responseObject.getStatusCode());
3146 responseBuilder.setAckFinalIndicator(ackFinal);
3147 trySetResponseMessage(responseBuilder, responseObject);
3148 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3149 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3151 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3152 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3154 if (ackFinal.equals("N")) {
3155 // Spawn background thread to invoke the Async DG
3156 Runnable backgroundThread = new Runnable() {
3158 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3159 processAsyncPortMirrorTopologyOperation(input);
3162 new Thread(backgroundThread).start();
3166 return Futures.immediateFuture(rpcResult);
3169 private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3170 return input == null || input.getServiceInformation() == null
3171 || input.getServiceInformation().getServiceInstanceId() == null
3172 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3175 private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3176 return input.getConfigurationInformation() == null
3177 || input.getConfigurationInformation().getConfigurationId() == null
3178 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3181 private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3182 PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3183 if (input.getSdncRequestHeader() != null) {
3184 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3188 private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3189 ResponseObject responseObject) {
3190 if (responseObject.getMessage() != null) {
3191 if (!responseObject.getMessage().isEmpty()) {
3192 responseBuilder.setResponseMessage(responseObject.getMessage());
3197 public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3198 log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3200 final String svcOperation = "port-mirror-topology-operation-async";
3201 ServiceData serviceData = null;
3202 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3203 Properties parms = new Properties();
3205 log.info(CALLED_STR, svcOperation);
3207 // Grab the service instance ID from the input buffer
3208 String siid = input.getServiceInformation().getServiceInstanceId();
3210 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3211 getServiceData(siid, serviceDataBuilder);
3213 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3214 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3216 // Set the serviceStatus based on input
3217 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3218 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3220 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3221 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3222 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3224 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3225 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3227 // Call SLI sync method
3228 ResponseObject responseObject = new ResponseObject("200", "");
3229 String ackFinal = "Y";
3230 String serviceObjectPath = null;
3231 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3233 if (respProps != null) {
3234 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3235 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3236 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3239 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3240 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3241 serviceStatusBuilder.setRpcName(svcOperation);
3243 if (failed(responseObject)) {
3244 ServiceBuilder serviceBuilder = new ServiceBuilder();
3245 serviceBuilder.setServiceInstanceId(siid);
3246 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3248 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3249 } catch (Exception e) {
3250 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3257 // Got success from SLI
3259 serviceData = serviceDataBuilder.build();
3260 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3263 ServiceBuilder serviceBuilder = new ServiceBuilder();
3264 serviceBuilder.setServiceData(serviceData);
3265 serviceBuilder.setServiceInstanceId(siid);
3266 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3267 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3269 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3270 // Only update operational tree on activate or delete
3271 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3272 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3273 log.info(UPDATING_TREE_INFO_MESSAGE);
3274 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3278 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3279 serviceResponseInformationBuilder.setInstanceId(siid);
3280 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3282 } catch (Exception e) {
3283 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3288 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3294 public Future<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(VnfGetResourceRequestInput input) {
3296 final String svcOperation = "vnf-get-resource-request";
3297 ServiceData serviceData;
3298 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3299 Properties parms = new Properties();
3301 log.info(CALLED_STR, svcOperation);
3302 // create a new response object
3303 VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3305 if (hasInvalidService(input)) {
3306 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3307 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3308 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3310 return Futures.immediateFuture(rpcResult);
3313 // Grab the service instance ID from the input buffer
3314 String siid = input.getServiceInformation().getServiceInstanceId();
3316 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3317 getServiceData(siid, serviceDataBuilder);
3319 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3320 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3322 // Set the serviceStatus based on input
3323 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3324 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3326 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3327 VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3328 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3330 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3331 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3333 // Call SLI sync method
3335 ResponseObject responseObject = new ResponseObject("200", "");
3336 String ackFinal = "Y";
3337 String serviceObjectPath = null;
3338 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3340 if (respProps != null) {
3341 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3342 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3343 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3344 serviceObjectPath = respProps.getProperty("service-object-path");
3347 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3348 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3349 serviceStatusBuilder.setRpcName(svcOperation);
3351 if (failed(responseObject)) {
3352 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3353 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3354 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3356 return Futures.immediateFuture(rpcResult);
3359 // Got success from SLI
3360 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3362 if (respProps != null) {
3363 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3366 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3367 .withResult(responseBuilder.build()).build();
3370 return Futures.immediateFuture(rpcResult);
3373 private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3374 return input == null || input.getServiceInformation() == null
3375 || input.getServiceInformation().getServiceInstanceId() == null
3376 || input.getServiceInformation().getServiceInstanceId().length() == 0;