1 package org.onap.sdnc.northbound;
3 import com.google.common.base.Optional;
4 import com.google.common.util.concurrent.CheckedFuture;
5 import com.google.common.util.concurrent.Futures;
6 import com.google.common.util.concurrent.ListenableFuture;
8 import java.text.DateFormat;
9 import java.text.SimpleDateFormat;
10 import java.util.Date;
11 import java.util.Properties;
12 import java.util.TimeZone;
13 import java.util.concurrent.ExecutionException;
14 import java.util.concurrent.ExecutorService;
15 import java.util.concurrent.Executors;
16 import java.util.concurrent.Future;
18 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
19 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
20 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
23 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
24 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
25 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
26 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInput;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInputBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationInput;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationInputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationNotificationOutput;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationInput;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationInputBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationOutput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GenericConfigurationTopologyOperationOutputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationInput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationInputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationOutput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GetpathsegmentTopologyOperationOutputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationInput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationInputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationOutput;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PolicyUpdateNotifyOperationOutputBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationInput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationInputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationOutput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PortMirrorTopologyOperationOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadInformation;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadInformationBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationInput;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationInputBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationOutput;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVfModuleTopologyOperationOutputBuilder;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestInput;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestInputBuilder;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestOutput;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfGetResourceRequestOutputBuilder;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PnfTopologyOperationInput;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PnfTopologyOperationInputBuilder;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PnfTopologyOperationOutput;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PnfTopologyOperationOutputBuilder;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.connection.attachment.response.information.ConnectionAttachmentResponseInformationBuilder;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.gc.response.information.GcResponseInformationBuilder;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.port.mirror.response.information.PortMirrorResponseInformationBuilder;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadList;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListBuilder;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListKey;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
126 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
127 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
128 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vf.module.response.information.VfModuleResponseInformationBuilder;
129 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vnf.response.information.VnfResponseInformationBuilder;
130 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.pnf.response.information.PnfResponseInformationBuilder;
131 import org.opendaylight.yangtools.yang.binding.DataObject;
132 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
133 import org.opendaylight.yangtools.yang.common.RpcResult;
134 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
135 import org.slf4j.Logger;
136 import org.slf4j.LoggerFactory;
139 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
140 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
141 * initialization / clean up methods.
143 * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule class which is
144 * auto generated under src/main/java in this project (created only once during first compilation):
149 * public java.lang.AutoCloseable createInstance() {
151 * // final GENERIC-RESOURCE-APIProvider provider = new
152 * // GENERIC-RESOURCE-APIProvider();
153 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
154 * provider.setDataBroker(getDataBrokerDependency());
155 * provider.setNotificationService(getNotificationServiceDependency());
156 * provider.setRpcRegistry(getRpcRegistryDependency());
157 * provider.initialize();
158 * return new AutoCloseable() {
161 * public void close() throws Exception {
162 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
163 * // BROKER/NOTIFICATION
164 * // SERVIE/RPC REGISTRY
173 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
175 protected static final String APP_NAME = "generic-resource-api";
176 private static final String CALLED_STR = "{} called.";
177 private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
178 protected static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
179 private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
180 private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
181 private static final String OPERATIONAL_DATA_PARAM = "operational-data";
182 protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
183 private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
184 private static final String ERROR_CODE_PARAM = "error-code";
185 private static final String ERROR_MESSAGE_PARAM = "error-message";
186 private static final String ACK_FINAL_PARAM = "ack-final";
187 private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
188 private static final String NETWORK_OBJECT_PATH_PARAM = "network-object-path";
189 private static final String VNF_OBJECT_PATH_PARAM = "vnf-object-path";
190 private static final String PNF_OBJECT_PATH_PARAM = "pnf-object-path";
191 private static final String VF_MODULE_OBJECT_PATH_PARAM = "vf-module-object-path";
192 private static final String VF_MODULE_ID_PARAM = "vf-module-id";
193 private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
194 private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
195 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
196 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
197 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
198 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
199 private static final String NON_NULL_PARAM = "non-null";
200 private static final String NULL_PARAM = "null";
201 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
202 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
203 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
204 protected static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
205 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
206 private static final String ERROR_NETWORK_ID = "error";
207 private static final String BACKGROUND_THREAD_STARTED_MESSAGE = "Start background thread";
208 private static final String BACKGROUND_THREAD_INFO = "Background thread: input conf_id is {}";
209 private static final String SKIP_MDSAL_UPDATE_PROP = "skip-mdsal-update";
211 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
212 private final ExecutorService executor;
213 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
215 protected DataBroker dataBroker;
216 protected NotificationPublishService notificationService;
217 protected RpcProviderRegistry rpcRegistry;
218 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
220 public GenericResourceApiProvider(DataBroker dataBroker, NotificationPublishService notificationPublishService,
221 RpcProviderRegistry rpcProviderRegistry, GenericResourceApiSvcLogicServiceClient client) {
222 log.info("Creating provider for {}", APP_NAME);
223 executor = Executors.newFixedThreadPool(1);
224 setDataBroker(dataBroker);
225 setNotificationService(notificationPublishService);
226 setRpcRegistry(rpcProviderRegistry);
227 svcLogicClient = client;
232 public void initialize() {
233 log.info("Initializing provider for {}", APP_NAME);
234 // Create the top level containers
237 GenericResourceApiUtil.loadProperties();
238 } catch (Exception e) {
239 log.error("Caught Exception while trying to load properties file", e);
242 log.info("Initialization complete for {}", APP_NAME);
245 protected void initializeChild() {
246 // Override if you have custom initialization intelligence
250 public void close() throws Exception {
251 log.info("Closing provider for {}", APP_NAME);
253 rpcRegistration.close();
254 log.info("Successfully closed provider for {}", APP_NAME);
257 private static class Iso8601Util {
259 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
260 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
262 private Iso8601Util() {
266 dateFormat.setTimeZone(timeZone);
269 private static String now() {
270 return dateFormat.format(new Date());
274 public void setDataBroker(DataBroker dataBroker) {
275 this.dataBroker = dataBroker;
276 if (log.isDebugEnabled()) {
277 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
281 public void setNotificationService(NotificationPublishService notificationService) {
282 this.notificationService = notificationService;
283 if (log.isDebugEnabled()) {
284 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
288 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
289 this.rpcRegistry = rpcRegistry;
290 if (log.isDebugEnabled()) {
291 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
295 private void createContainers() {
297 final WriteTransaction t = dataBroker.newReadWriteTransaction();
299 // Create the service-instance container
300 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
301 new ServicesBuilder().build());
302 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
303 new ServicesBuilder().build());
305 // Create the PreloadInformation container
306 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadInformation.class),
307 new PreloadInformationBuilder().build());
308 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadInformation.class),
309 new PreloadInformationBuilder().build());
312 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
314 log.info("Create containers succeeded!");
316 } catch (InterruptedException | ExecutionException e) {
317 log.error("Create containers failed: ", e);
321 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
323 serviceStatusBuilder.setResponseCode(errorCode);
324 serviceStatusBuilder.setResponseMessage(errorMessage);
325 serviceStatusBuilder.setFinalIndicator(ackFinal);
326 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
329 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
330 if (requestInformation != null && requestInformation.getRequestAction() != null) {
331 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
335 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
336 if (requestHeader != null && requestHeader.getSvcAction() != null) {
337 switch (requestHeader.getSvcAction()) {
339 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
342 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
345 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
348 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
351 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
354 serviceStatusBuilder.setRpcAction(RpcAction.Create);
357 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
363 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
365 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
368 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
369 // See if any data exists yet for this siid, if so grab it.
370 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier.builder(Services.class)
371 .child(Service.class, new ServiceKey(siid)).build();
373 Optional<Service> data = Optional.absent();
374 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
375 data = readTx.read(type, serviceInstanceIdentifier).get();
376 } catch (final InterruptedException | ExecutionException e) {
377 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
380 if (data != null && data.isPresent()) {
381 ServiceData serviceData = data.get().getServiceData();
382 if (serviceData != null) {
383 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
384 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
385 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
386 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
387 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
388 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
389 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
390 serviceDataBuilder.setNetworks(serviceData.getNetworks());
391 serviceDataBuilder.setVnfs(serviceData.getVnfs());
392 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
393 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
394 serviceDataBuilder.setNetworkInstanceGroups(serviceData.getNetworkInstanceGroups());
395 serviceDataBuilder.setVnfcInstanceGroups(serviceData.getVnfcInstanceGroups());
396 serviceDataBuilder.setForwardingPaths(serviceData.getForwardingPaths());
397 serviceDataBuilder.setProvidedConfigurations(serviceData.getProvidedConfigurations());
398 // service-instance-id needs to be set
400 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
403 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
407 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
408 // Each entry will be identifiable by a unique key, we have to create that
410 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
411 .child(Service.class, entry.key()).build();
413 trySaveEntry(entry, merge, storeType, path);
416 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
417 InstanceIdentifier<T> path) {
421 save(entry, merge, storeType, path);
423 } catch (OptimisticLockFailedException e) {
425 log.debug("Got OptimisticLockFailedException on last try - failing ");
426 throw new IllegalStateException(e);
428 log.debug("Got OptimisticLockFailedException - trying again ");
429 } catch (TransactionCommitFailedException ex) {
430 log.debug("Update DataStore failed");
431 throw new IllegalStateException(ex);
436 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
437 InstanceIdentifier<T> path) throws TransactionCommitFailedException {
438 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
440 tx.merge(storeType, path, entry);
442 tx.put(storeType, path, entry);
444 tx.submit().checkedGet();
445 log.debug("Update DataStore succeeded");
448 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
449 // Each entry will be identifiable by a unique key, we have to create
451 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
452 .child(Service.class, entry.key()).build();
454 tryDeleteEntry(storeType, path);
457 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
461 delete(storeType, path);
463 } catch (OptimisticLockFailedException e) {
465 log.debug("Got OptimisticLockFailedException on last try - failing ");
466 throw new IllegalStateException(e);
468 log.debug("Got OptimisticLockFailedException - trying again ");
469 } catch (TransactionCommitFailedException ex) {
470 log.debug("Update DataStore failed");
471 throw new IllegalStateException(ex);
476 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
477 throws TransactionCommitFailedException {
478 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
479 tx.delete(storeType, path);
480 tx.submit().checkedGet();
481 log.debug("DataStore delete succeeded");
484 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
486 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
489 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
490 LogicalDatastoreType type) {
491 // See if any data exists yet for this name/type, if so grab it.
492 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier
493 .<PreloadInformation>builder(PreloadInformation.class)
494 .child(PreloadList.class, new PreloadListKey(preloadName, preloadType)).build();
496 Optional<PreloadList> data = null;
497 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
498 data = (Optional<PreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
499 } catch (final InterruptedException | ExecutionException e) {
500 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
503 if (data != null && data.isPresent()) {
504 PreloadData preloadData = data.get().getPreloadData();
505 if (preloadData != null) {
506 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
509 .setPreloadVfModuleTopologyInformation(preloadData.getPreloadVfModuleTopologyInformation());
511 .setPreloadNetworkTopologyInformation(preloadData.getPreloadNetworkTopologyInformation());
512 preloadDataBuilder.setPreloadOperStatus(preloadData.getPreloadOperStatus());
514 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
517 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
521 private void savePreloadList(final PreloadList entry, boolean merge, LogicalDatastoreType storeType)
522 throws IllegalStateException {
524 // Each entry will be identifiable by a unique key, we have to create that
526 InstanceIdentifier.InstanceIdentifierBuilder<PreloadList> preloadListBuilder = InstanceIdentifier
527 .<PreloadInformation>builder(PreloadInformation.class).child(PreloadList.class, entry.key());
528 InstanceIdentifier<PreloadList> path = preloadListBuilder.build();
532 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
534 tx.merge(storeType, path, entry);
536 tx.put(storeType, path, entry);
538 tx.submit().checkedGet();
539 log.debug("Update DataStore succeeded");
541 } catch (final TransactionCommitFailedException e) {
542 if (e instanceof OptimisticLockFailedException) {
544 log.debug("Got OptimisticLockFailedException on last try - failing ");
545 throw new IllegalStateException(e);
547 log.debug("Got OptimisticLockFailedException - trying again ");
549 log.debug("Update DataStore failed");
550 throw new IllegalStateException(e);
556 private void deletePreloadList(final PreloadList entry, LogicalDatastoreType storeType) {
557 // Each entry will be identifiable by a unique key, we have to create
559 InstanceIdentifier<PreloadList> path = InstanceIdentifier.builder(PreloadInformation.class)
560 .child(PreloadList.class, entry.key()).build();
562 tryDeletePreloadListEntry(storeType, path);
565 private void tryDeletePreloadListEntry(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path) {
569 deletePreloadList(storeType, path);
571 } catch (OptimisticLockFailedException e) {
573 log.debug("Got OptimisticLockFailedException on last try - failing ");
574 throw new IllegalStateException(e);
576 log.debug("Got OptimisticLockFailedException - trying again ");
577 } catch (TransactionCommitFailedException ex) {
578 log.debug("Update DataStore failed");
579 throw new IllegalStateException(ex);
584 private void deletePreloadList(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path)
585 throws TransactionCommitFailedException {
586 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
587 tx.delete(storeType, path);
588 tx.submit().checkedGet();
589 log.debug("DataStore delete succeeded");
593 public ListenableFuture<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
594 ServiceTopologyOperationInput input) {
596 final String svcOperation = "service-topology-operation";
597 ServiceData serviceData;
598 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
599 Properties parms = new Properties();
601 log.info(CALLED_STR, svcOperation);
602 // create a new response object
603 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
605 if (hasInvalidServiceId(input)) {
606 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
607 responseBuilder.setResponseCode("404");
608 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
609 responseBuilder.setAckFinalIndicator("Y");
611 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
612 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
614 return Futures.immediateFuture(rpcResult);
617 // Grab the service instance ID from the input buffer
618 String siid = input.getServiceInformation().getServiceInstanceId();
620 trySetSvcRequestId(input, responseBuilder);
622 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
623 getServiceData(siid, serviceDataBuilder);
625 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
626 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
628 // Set the serviceStatus based on input
629 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
630 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
633 * // setup a service-data object builder // ACTION service-topology-operation
634 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
635 * topology-response-common; // uses service-response-information;
638 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
639 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
640 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
642 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
643 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
645 // Call SLI sync method
646 ResponseObject responseObject = new ResponseObject("200", "");
647 String ackFinal = "Y";
648 String serviceObjectPath = null;
649 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
651 if (respProps != null) {
652 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
653 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
654 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
655 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
658 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
659 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
660 serviceStatusBuilder.setRpcName(svcOperation);
662 if (failed(responseObject)) {
663 responseBuilder.setResponseCode(responseObject.getStatusCode());
664 responseBuilder.setResponseMessage(responseObject.getMessage());
665 responseBuilder.setAckFinalIndicator(ackFinal);
667 ServiceBuilder serviceBuilder = new ServiceBuilder();
668 serviceBuilder.setServiceInstanceId(siid);
669 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
671 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
672 } catch (Exception e) {
673 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
675 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
677 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
678 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
680 return Futures.immediateFuture(rpcResult);
683 // Got success from SLI
685 serviceData = serviceDataBuilder.build();
686 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
689 ServiceBuilder serviceBuilder = new ServiceBuilder();
690 serviceBuilder.setServiceData(serviceData);
691 serviceBuilder.setServiceInstanceId(siid);
692 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
693 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
695 tryDeleteService(input, serviceBuilder);
697 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
698 serviceResponseInformationBuilder.setInstanceId(siid);
699 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
700 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
702 } catch (Exception e) {
703 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
704 responseBuilder.setResponseCode("500");
705 responseBuilder.setResponseMessage(e.getMessage());
706 responseBuilder.setAckFinalIndicator("Y");
707 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
709 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
710 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
712 return Futures.immediateFuture(rpcResult);
716 responseBuilder.setResponseCode(responseObject.getStatusCode());
717 responseBuilder.setAckFinalIndicator(ackFinal);
718 trySetResponseMessage(responseBuilder, responseObject);
719 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
720 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
722 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
723 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
725 return Futures.immediateFuture(rpcResult);
728 private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder,
729 ResponseObject responseObject) {
730 if (responseObject.getMessage() != null) {
731 responseBuilder.setResponseMessage(responseObject.getMessage());
735 private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
736 return input == null || input.getServiceInformation() == null
737 || input.getServiceInformation().getServiceInstanceId() == null
738 || input.getServiceInformation().getServiceInstanceId().length() == 0;
741 private void trySetSvcRequestId(ServiceTopologyOperationInput input,
742 ServiceTopologyOperationOutputBuilder responseBuilder) {
743 if (input.getSdncRequestHeader() != null) {
744 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
748 private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
749 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
750 // Only update operational tree on delete
751 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
752 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
753 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
757 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
758 ResponseObject responseObject) {
760 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
762 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
763 } catch (Exception e) {
764 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
765 responseObject.setMessage(e.getMessage());
766 responseObject.setStatusCode("500");
769 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
770 responseObject.setStatusCode("503");
772 } catch (Exception e) {
773 responseObject.setMessage(e.getMessage());
774 responseObject.setStatusCode("500");
775 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
781 private boolean failed(ResponseObject error) {
782 return !error.getStatusCode().isEmpty()
783 && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
786 private boolean isValidRequest(ServiceTopologyOperationInput input) {
787 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
792 public ListenableFuture<RpcResult<PnfTopologyOperationOutput>> pnfTopologyOperation(
793 PnfTopologyOperationInput input) {
795 final String svcOperation = "pnf-topology-operation";
796 ServiceData serviceData;
797 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
798 Properties properties = new Properties();
800 log.info(CALLED_STR, svcOperation);
801 // create a new response object
802 PnfTopologyOperationOutputBuilder responseBuilder = new PnfTopologyOperationOutputBuilder();
804 if (hasInvalidServiceId(input)) {
805 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
806 responseBuilder.setResponseCode("404");
807 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
808 responseBuilder.setAckFinalIndicator("Y");
809 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
810 .withResult(responseBuilder.build()).build();
812 return Futures.immediateFuture(rpcResult);
815 // Grab the service instance ID from the input buffer
816 String siid = input.getServiceInformation().getServiceInstanceId();
818 trySetSvcRequestId(input, responseBuilder);
820 /* Comment out mandatory check for pnf id for scenario wherein for assign/create request pnf-id is generated by
822 if (hasInvalidPnfId(input)) {
823 log.debug("exiting {} because of null or empty pnf-id", svcOperation);
824 responseBuilder.setResponseCode("404");
825 responseBuilder.setResponseMessage("invalid input, null or empty pnf-id");
826 responseBuilder.setAckFinalIndicator("Y");
828 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
829 .withResult(responseBuilder.build()).build();
831 return Futures.immediateFuture(rpcResult);
835 String pnfId = input.getPnfDetails().getPnfId();
836 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
837 getServiceData(siid, serviceDataBuilder);
839 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
840 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
842 // Set the serviceStatus based on input
843 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
844 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
847 // setup a service-data object builder
848 // ACTION pnf-topology-operation
850 // USES sdnc-request-header;
851 // USES request-information;
852 // USES service-information;
855 // USES pnf-topology-response-body;
857 // USES service-information
861 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
862 PnfTopologyOperationInputBuilder inputBuilder = new PnfTopologyOperationInputBuilder(input);
863 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
865 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
866 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
868 // Call SLI sync method
870 ResponseObject responseObject = new ResponseObject("200", "");
871 String ackFinal = "Y";
872 String serviceObjectPath = null;
873 String pnfObjectPath = null;
874 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
876 if (respProps != null) {
877 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
878 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
879 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
881 pnfId = respProps.getProperty("pnfId");
883 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
884 pnfObjectPath = respProps.getProperty(PNF_OBJECT_PATH_PARAM);
887 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
888 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
889 serviceStatusBuilder.setRpcName(svcOperation);
891 if (failed(responseObject)) {
892 responseBuilder.setResponseCode(responseObject.getStatusCode());
893 responseBuilder.setResponseMessage(responseObject.getMessage());
894 responseBuilder.setAckFinalIndicator(ackFinal);
896 ServiceBuilder serviceBuilder = new ServiceBuilder();
897 serviceBuilder.setServiceInstanceId(siid);
898 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
900 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
901 trySaveService(input, serviceBuilder);
902 } catch (Exception e) {
903 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
905 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
907 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
908 .withResult(responseBuilder.build()).build();
911 return Futures.immediateFuture(rpcResult);
914 // Got success from SLI
916 serviceData = serviceDataBuilder.build();
917 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
920 ServiceBuilder serviceBuilder = new ServiceBuilder();
921 serviceBuilder.setServiceData(serviceData);
922 serviceBuilder.setServiceInstanceId(siid);
923 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
924 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
926 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
927 // Only update operational tree on Assign
928 log.info(UPDATING_TREE_INFO_MESSAGE);
929 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
932 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
933 serviceResponseInformationBuilder.setInstanceId(siid);
934 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
935 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
937 PnfResponseInformationBuilder pnfResponseInformationBuilder = new PnfResponseInformationBuilder();
938 pnfResponseInformationBuilder.setInstanceId(pnfId);
939 pnfResponseInformationBuilder.setObjectPath(pnfObjectPath);
940 responseBuilder.setPnfResponseInformation(pnfResponseInformationBuilder.build());
942 } catch (Exception e) {
943 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
944 responseBuilder.setResponseCode("500");
945 responseBuilder.setResponseMessage(e.getMessage());
946 responseBuilder.setAckFinalIndicator("Y");
947 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
949 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
950 .withResult(responseBuilder.build()).build();
952 return Futures.immediateFuture(rpcResult);
956 responseBuilder.setResponseCode(responseObject.getStatusCode());
957 responseBuilder.setAckFinalIndicator(ackFinal);
958 trySetResponseMessage(responseBuilder, responseObject);
959 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
960 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
962 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
963 .withResult(responseBuilder.build()).build();
966 return Futures.immediateFuture(rpcResult);
969 private void trySetResponseMessage(PnfTopologyOperationOutputBuilder responseBuilder,
970 ResponseObject responseObject) {
971 if (responseObject.getMessage() != null) {
972 responseBuilder.setResponseMessage(responseObject.getMessage());
976 private void trySaveService(PnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
977 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
978 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
980 // Only update operational tree on activate or delete
981 log.info(UPDATING_TREE_INFO_MESSAGE);
982 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
986 private boolean hasInvalidPnfId(PnfTopologyOperationInput input) {
987 return input.getPnfDetails() == null || input.getPnfDetails().getPnfId() == null
988 || input.getPnfDetails().getPnfId().length() == 0;
991 private boolean hasInvalidServiceId(PnfTopologyOperationInput input) {
992 return input == null || input.getServiceInformation() == null
993 || input.getServiceInformation().getServiceInstanceId() == null
994 || input.getServiceInformation().getServiceInstanceId().length() == 0;
997 private void trySetSvcRequestId(PnfTopologyOperationInput input,
998 PnfTopologyOperationOutputBuilder responseBuilder) {
999 if (input.getSdncRequestHeader() != null) {
1000 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1004 private boolean isValidRequest(PnfTopologyOperationInput input) {
1005 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1010 public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
1011 VnfTopologyOperationInput input) {
1013 final String svcOperation = "vnf-topology-operation";
1014 ServiceData serviceData;
1015 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1016 Properties properties = new Properties();
1018 log.info(CALLED_STR, svcOperation);
1019 // create a new response object
1020 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1022 if (hasInvalidServiceId(input)) {
1023 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1024 responseBuilder.setResponseCode("404");
1025 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1026 responseBuilder.setAckFinalIndicator("Y");
1027 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1028 .withResult(responseBuilder.build()).build();
1030 return Futures.immediateFuture(rpcResult);
1033 // Grab the service instance ID from the input buffer
1034 String siid = input.getServiceInformation().getServiceInstanceId();
1036 trySetSvcRequestId(input, responseBuilder);
1038 /* Comment out mandatory check for vnf id for scenario wherein for assign/create request vnf-id is generated by
1040 if (hasInvalidVnfId(input)) {
1041 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1042 responseBuilder.setResponseCode("404");
1043 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1044 responseBuilder.setAckFinalIndicator("Y");
1046 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1047 .withResult(responseBuilder.build()).build();
1049 return Futures.immediateFuture(rpcResult);
1053 String vnfId = input.getVnfInformation().getVnfId();
1054 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1055 getServiceData(siid, serviceDataBuilder);
1057 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1058 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1060 // Set the serviceStatus based on input
1061 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1062 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1065 // setup a service-data object builder
1066 // ACTION vnf-topology-operation
1068 // USES sdnc-request-header;
1069 // USES request-information;
1070 // USES service-information;
1071 // USES vnf-request-information
1073 // USES vnf-topology-response-body;
1074 // USES vnf-information
1075 // USES service-information
1077 // container service-data
1078 // uses vnf-configuration-information;
1079 // uses oper-status;
1081 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1082 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1083 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1085 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1086 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
1088 // Call SLI sync method
1090 ResponseObject responseObject = new ResponseObject("200", "");
1091 String ackFinal = "Y";
1092 String serviceObjectPath = null;
1093 String vnfObjectPath = null;
1094 String skipMdsalUpdate = null;
1095 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1097 if (respProps != null) {
1098 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1099 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1100 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1101 if (vnfId == null) {
1102 vnfId = respProps.getProperty("vnfId");
1104 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1105 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1106 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1107 if (skipMdsalUpdate == null) {
1108 skipMdsalUpdate = "N";
1112 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1113 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1114 serviceStatusBuilder.setRpcName(svcOperation);
1116 if (failed(responseObject)) {
1117 responseBuilder.setResponseCode(responseObject.getStatusCode());
1118 responseBuilder.setResponseMessage(responseObject.getMessage());
1119 responseBuilder.setAckFinalIndicator(ackFinal);
1121 ServiceBuilder serviceBuilder = new ServiceBuilder();
1122 serviceBuilder.setServiceInstanceId(siid);
1123 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1125 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1126 trySaveService(input, serviceBuilder);
1127 } catch (Exception e) {
1128 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1130 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1132 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1133 .withResult(responseBuilder.build()).build();
1136 return Futures.immediateFuture(rpcResult);
1139 // Got success from SLI
1141 if (skipMdsalUpdate.equals("N")) {
1142 serviceData = serviceDataBuilder.build();
1143 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1146 ServiceBuilder serviceBuilder = new ServiceBuilder();
1147 serviceBuilder.setServiceData(serviceData);
1148 serviceBuilder.setServiceInstanceId(siid);
1149 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1150 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1152 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1153 // Only update operational tree on Assign
1154 log.info(UPDATING_TREE_INFO_MESSAGE);
1155 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1158 // Even if we are skipping the MD-SAL update, update the service status object
1159 ServiceBuilder serviceBuilder = new ServiceBuilder();
1160 serviceBuilder.setServiceInstanceId(siid);
1161 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1162 Service service = serviceBuilder.build();
1163 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1164 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1167 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1168 serviceResponseInformationBuilder.setInstanceId(siid);
1169 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1170 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1172 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1173 vnfResponseInformationBuilder.setInstanceId(vnfId);
1174 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1175 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1177 } catch (Exception e) {
1178 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1179 responseBuilder.setResponseCode("500");
1180 responseBuilder.setResponseMessage(e.getMessage());
1181 responseBuilder.setAckFinalIndicator("Y");
1182 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1184 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1185 .withResult(responseBuilder.build()).build();
1187 return Futures.immediateFuture(rpcResult);
1191 responseBuilder.setResponseCode(responseObject.getStatusCode());
1192 responseBuilder.setAckFinalIndicator(ackFinal);
1193 trySetResponseMessage(responseBuilder, responseObject);
1194 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1195 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1197 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1198 .withResult(responseBuilder.build()).build();
1200 if (ackFinal.equals("N")) {
1201 // Spawn background thread to invoke the Async DG
1202 Runnable backgroundThread = new Runnable() {
1204 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
1205 processAsyncVnfTopologyOperation(input);
1208 new Thread(backgroundThread).start();
1212 return Futures.immediateFuture(rpcResult);
1215 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
1216 ResponseObject responseObject) {
1217 if (responseObject.getMessage() != null) {
1218 responseBuilder.setResponseMessage(responseObject.getMessage());
1222 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1223 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
1224 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1226 // Only update operational tree on activate or delete
1227 log.info(UPDATING_TREE_INFO_MESSAGE);
1228 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1232 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
1233 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1234 || input.getVnfInformation().getVnfId().length() == 0;
1237 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
1238 return input == null || input.getServiceInformation() == null
1239 || input.getServiceInformation().getServiceInstanceId() == null
1240 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1243 private void trySetSvcRequestId(VnfTopologyOperationInput input,
1244 VnfTopologyOperationOutputBuilder responseBuilder) {
1245 if (input.getSdncRequestHeader() != null) {
1246 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1250 private boolean isValidRequest(VnfTopologyOperationInput input) {
1251 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1254 public void processAsyncVnfTopologyOperation(VnfTopologyOperationInput input) {
1255 log.info(BACKGROUND_THREAD_INFO, input.getVnfInformation().getVnfId());
1257 final String svcOperation = "vnf-topology-operation-async";
1258 ServiceData serviceData = null;
1259 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1260 Properties parms = new Properties();
1262 log.info(CALLED_STR, svcOperation);
1264 // create a new response object (for logging purposes only)
1265 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1267 // Grab the service instance ID from the input buffer
1268 String siid = input.getServiceInformation().getServiceInstanceId();
1269 String vnfId = input.getVnfInformation().getVnfId();
1271 trySetSvcRequestId(input, responseBuilder);
1273 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1274 getServiceData(siid, serviceDataBuilder);
1276 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1277 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1279 // Set the serviceStatus based on input
1280 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1281 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1284 // setup a service-data object builder
1285 // ACTION vnf-topology-operation
1287 // USES sdnc-request-header;
1288 // USES request-information;
1289 // USES service-information;
1290 // USES vnf-request-information
1292 // USES vnf-topology-response-body;
1293 // USES vnf-information
1294 // USES service-information
1296 // container service-data
1297 // uses vnf-configuration-information;
1298 // uses oper-status;
1300 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1301 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1302 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1304 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1305 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1307 // Call SLI sync method
1309 ResponseObject responseObject = new ResponseObject("200", "");
1310 String ackFinal = "Y";
1311 String serviceObjectPath = null;
1312 String vnfObjectPath = null;
1313 String skipMdsalUpdate = null;
1314 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1316 if (respProps != null) {
1317 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1318 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1319 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1320 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1321 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1322 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1323 if (skipMdsalUpdate == null) {
1324 skipMdsalUpdate = "N";
1328 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1329 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1330 serviceStatusBuilder.setRpcName(svcOperation);
1332 if (failed(responseObject)) {
1333 responseBuilder.setResponseCode(responseObject.getStatusCode());
1334 responseBuilder.setResponseMessage(responseObject.getMessage());
1335 responseBuilder.setAckFinalIndicator(ackFinal);
1337 ServiceBuilder serviceBuilder = new ServiceBuilder();
1338 serviceBuilder.setServiceInstanceId(siid);
1339 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1341 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1342 } catch (Exception e) {
1343 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1345 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1349 // Got success from SLI
1351 if (skipMdsalUpdate.equals("N")) {
1352 serviceData = serviceDataBuilder.build();
1353 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1356 ServiceBuilder serviceBuilder = new ServiceBuilder();
1357 serviceBuilder.setServiceData(serviceData);
1358 serviceBuilder.setServiceInstanceId(siid);
1359 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1360 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1362 trySaveService(input, serviceBuilder);
1364 // Even if we are skipping the MD-SAL update, update the service status object
1365 ServiceBuilder serviceBuilder = new ServiceBuilder();
1366 serviceBuilder.setServiceInstanceId(siid);
1367 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1368 Service service = serviceBuilder.build();
1369 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1370 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1373 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1374 serviceResponseInformationBuilder.setInstanceId(siid);
1375 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1376 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1378 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1379 vnfResponseInformationBuilder.setInstanceId(vnfId);
1380 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1381 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1383 } catch (Exception e) {
1384 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1385 responseBuilder.setResponseCode("500");
1386 responseBuilder.setResponseMessage(e.getMessage());
1387 responseBuilder.setAckFinalIndicator("Y");
1388 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1394 responseBuilder.setResponseCode(responseObject.getStatusCode());
1395 responseBuilder.setAckFinalIndicator(ackFinal);
1396 trySetResponseMessage(responseBuilder, responseObject);
1397 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1398 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1403 public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1404 VfModuleTopologyOperationInput input) {
1406 final String svcOperation = "vf-module-topology-operation";
1407 ServiceData serviceData;
1408 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1409 Properties parms = new Properties();
1411 log.info(CALLED_STR, svcOperation);
1412 // create a new response object
1413 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1415 if (hasInvalidServiceId(input)) {
1416 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1417 responseBuilder.setResponseCode("403");
1418 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1419 responseBuilder.setAckFinalIndicator("Y");
1421 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1422 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1425 return Futures.immediateFuture(rpcResult);
1428 if (hasInvalidVnfId(input)) {
1429 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1430 responseBuilder.setResponseCode("403");
1431 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1432 responseBuilder.setAckFinalIndicator("Y");
1433 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1434 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1435 return Futures.immediateFuture(rpcResult);
1438 /*if (hasInvalidVfModuleId(input)) {
1439 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1440 responseBuilder.setResponseCode("403");
1441 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1442 responseBuilder.setAckFinalIndicator("Y");
1444 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1445 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1447 return Futures.immediateFuture(rpcResult);
1450 // Grab the service instance ID from the input buffer
1451 String siid = input.getServiceInformation().getServiceInstanceId();
1452 String vnfId = input.getVnfInformation().getVnfId();
1453 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1455 trySetSvcRequestId(input, responseBuilder);
1457 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1458 getServiceData(siid, serviceDataBuilder);
1460 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1461 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1463 // Set the serviceStatus based on input
1464 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1465 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1468 // setup a service-data object builder
1469 // ACTION vnf-topology-operation
1471 // USES sdnc-request-header;
1472 // USES request-information;
1473 // USES service-information;
1474 // USES vnf-request-information
1476 // USES vnf-topology-response-body;
1477 // USES vnf-information
1478 // USES service-information
1480 // container service-data
1481 // uses vnf-configuration-information;
1482 // uses oper-status;
1484 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1485 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1486 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1488 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1489 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1491 // Call SLI sync method
1493 ResponseObject responseObject = new ResponseObject("200", "");
1494 String ackFinal = "Y";
1495 String serviceObjectPath = null;
1496 String vnfObjectPath = null;
1497 String vfModuleObjectPath = null;
1498 String skipMdsalUpdate = null;
1499 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1501 if (respProps != null) {
1502 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1503 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1504 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1505 if (vfModuleId == null) {
1506 vfModuleId = respProps.getProperty(VF_MODULE_ID_PARAM);
1507 if (vfModuleId == null) {
1508 log.debug("exiting {} because vf-module-id not found in response", svcOperation);
1509 responseBuilder.setResponseCode("403");
1510 responseBuilder.setResponseMessage("failed to generate vf-module-id");
1511 responseBuilder.setAckFinalIndicator("Y");
1513 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1514 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1516 return Futures.immediateFuture(rpcResult);
1519 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1520 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1521 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1522 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1523 if (skipMdsalUpdate == null) {
1524 skipMdsalUpdate = "N";
1528 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1529 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1530 serviceStatusBuilder.setRpcName(svcOperation);
1532 if (failed(responseObject)) {
1533 responseBuilder.setResponseCode(responseObject.getStatusCode());
1534 responseBuilder.setResponseMessage(responseObject.getMessage());
1535 responseBuilder.setAckFinalIndicator(ackFinal);
1537 ServiceBuilder serviceBuilder = new ServiceBuilder();
1538 serviceBuilder.setServiceInstanceId(siid);
1539 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1541 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1542 } catch (Exception e) {
1543 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1545 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1547 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1548 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1551 return Futures.immediateFuture(rpcResult);
1554 // Got success from SLI
1556 if (skipMdsalUpdate.equals("N")) {
1557 serviceData = serviceDataBuilder.build();
1558 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1561 ServiceBuilder serviceBuilder = new ServiceBuilder();
1562 serviceBuilder.setServiceData(serviceData);
1563 serviceBuilder.setServiceInstanceId(siid);
1564 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1565 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1567 trySaveService(input, serviceBuilder);
1569 // Even if we are skipping the MD-SAL update, update the service status object
1570 ServiceBuilder serviceBuilder = new ServiceBuilder();
1571 serviceBuilder.setServiceInstanceId(siid);
1572 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1573 Service service = serviceBuilder.build();
1574 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1575 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1578 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1579 serviceResponseInformationBuilder.setInstanceId(siid);
1580 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1581 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1583 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1584 vnfResponseInformationBuilder.setInstanceId(vnfId);
1585 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1586 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1588 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1589 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1590 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1591 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1593 } catch (Exception e) {
1594 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1595 responseBuilder.setResponseCode("500");
1596 responseBuilder.setResponseMessage(e.getMessage());
1597 responseBuilder.setAckFinalIndicator("Y");
1598 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1600 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1601 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1603 return Futures.immediateFuture(rpcResult);
1607 responseBuilder.setResponseCode(responseObject.getStatusCode());
1608 responseBuilder.setAckFinalIndicator(ackFinal);
1609 trySetResponseMessage(responseBuilder, responseObject);
1610 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1611 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1613 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1614 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1616 if (ackFinal.equals("N")) {
1617 // Spawn background thread to invoke the Async DG
1618 Runnable backgroundThread = new Runnable() {
1620 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
1621 processAsyncVfModuleTopologyOperation(input);
1624 new Thread(backgroundThread).start();
1628 return Futures.immediateFuture(rpcResult);
1631 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1632 ResponseObject responseObject) {
1633 if (responseObject.getMessage() != null) {
1634 responseBuilder.setResponseMessage(responseObject.getMessage());
1638 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1639 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1640 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1641 // Only update operational tree on activate or delete
1643 log.info(UPDATING_TREE_INFO_MESSAGE);
1644 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1648 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1649 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1650 if (input.getSdncRequestHeader() != null) {
1651 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1655 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1656 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1657 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1660 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1661 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1662 || input.getVnfInformation().getVnfId().length() == 0;
1665 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1666 return input == null || input.getServiceInformation() == null
1667 || input.getServiceInformation().getServiceInstanceId() == null
1668 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1671 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1672 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1675 public void processAsyncVfModuleTopologyOperation(VfModuleTopologyOperationInput input) {
1676 log.info(BACKGROUND_THREAD_INFO, input.getVfModuleInformation().getVfModuleId());
1678 final String svcOperation = "vf-module-topology-operation-async";
1679 ServiceData serviceData = null;
1680 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1681 Properties parms = new Properties();
1683 log.info(CALLED_STR, svcOperation);
1685 // create a new response object (for logging purposes only)
1686 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1688 // Grab the service instance ID from the input buffer
1689 String siid = input.getServiceInformation().getServiceInstanceId();
1690 String vnfId = input.getVnfInformation().getVnfId();
1691 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1693 trySetSvcRequestId(input, responseBuilder);
1695 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1696 getServiceData(siid, serviceDataBuilder);
1698 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1699 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1701 // Set the serviceStatus based on input
1702 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1703 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1706 // setup a service-data object builder
1707 // ACTION vnf-topology-operation
1709 // USES sdnc-request-header;
1710 // USES request-information;
1711 // USES service-information;
1712 // USES vnf-request-information
1714 // USES vnf-topology-response-body;
1715 // USES vnf-information
1716 // USES service-information
1718 // container service-data
1719 // uses vnf-configuration-information;
1720 // uses oper-status;
1722 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1723 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1724 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1726 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1727 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1729 // Call SLI sync method
1731 ResponseObject responseObject = new ResponseObject("200", "");
1732 String ackFinal = "Y";
1733 String serviceObjectPath = null;
1734 String vnfObjectPath = null;
1735 String vfModuleObjectPath = null;
1736 String skipMdsalUpdate = null;
1737 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1739 if (respProps != null) {
1740 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1741 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1742 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1743 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1744 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1745 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1746 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1747 if (skipMdsalUpdate == null) {
1748 skipMdsalUpdate = "N";
1752 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1753 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1754 serviceStatusBuilder.setRpcName(svcOperation);
1756 if (failed(responseObject)) {
1757 responseBuilder.setResponseCode(responseObject.getStatusCode());
1758 responseBuilder.setResponseMessage(responseObject.getMessage());
1759 responseBuilder.setAckFinalIndicator(ackFinal);
1761 ServiceBuilder serviceBuilder = new ServiceBuilder();
1762 serviceBuilder.setServiceInstanceId(siid);
1763 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1765 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1766 } catch (Exception e) {
1767 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1769 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1773 // Got success from SLI
1775 if (skipMdsalUpdate.equals("N")) {
1776 serviceData = serviceDataBuilder.build();
1777 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1780 ServiceBuilder serviceBuilder = new ServiceBuilder();
1781 serviceBuilder.setServiceData(serviceData);
1782 serviceBuilder.setServiceInstanceId(siid);
1783 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1784 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1786 trySaveService(input, serviceBuilder);
1788 // Even if we are skipping the MD-SAL update, update the service status object
1789 ServiceBuilder serviceBuilder = new ServiceBuilder();
1790 serviceBuilder.setServiceInstanceId(siid);
1791 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1792 Service service = serviceBuilder.build();
1793 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1794 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1797 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1798 serviceResponseInformationBuilder.setInstanceId(siid);
1799 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1800 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1802 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1803 vnfResponseInformationBuilder.setInstanceId(vnfId);
1804 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1805 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1807 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1808 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1809 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1810 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1812 } catch (Exception e) {
1813 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1814 responseBuilder.setResponseCode("500");
1815 responseBuilder.setResponseMessage(e.getMessage());
1816 responseBuilder.setAckFinalIndicator("Y");
1817 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1823 responseBuilder.setResponseCode(responseObject.getStatusCode());
1824 responseBuilder.setAckFinalIndicator(ackFinal);
1825 trySetResponseMessage(responseBuilder, responseObject);
1826 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1827 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1832 public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1833 NetworkTopologyOperationInput input) {
1835 final String svcOperation = "network-topology-operation";
1836 ServiceData serviceData;
1837 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1838 Properties parms = new Properties();
1840 log.info(CALLED_STR, svcOperation);
1841 // create a new response object
1842 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1844 if (hasInvalidServiceId(input)) {
1845 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1846 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1849 String siid = input.getServiceInformation().getServiceInstanceId();
1851 // Get the service-instance service data from MD-SAL
1852 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1853 getServiceData(siid, serviceDataBuilder);
1855 this.trySetSvcRequestId(input, responseBuilder);
1857 ServiceData sd = serviceDataBuilder.build();
1858 if (isInvalidServiceData(sd)) {
1859 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1860 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1863 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1864 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1865 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1867 // Call SLI sync method
1869 ResponseObject responseObject = new ResponseObject("200", "");
1870 String ackFinal = "Y";
1871 String networkId = ERROR_NETWORK_ID;
1872 String serviceObjectPath = null;
1873 String networkObjectPath = null;
1874 String skipMdsalUpdate = null;
1875 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1877 if (respProps != null) {
1878 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1879 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1880 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1881 networkId = respProps.getProperty("networkId");
1882 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1883 networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1884 skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1885 if (skipMdsalUpdate == null) {
1886 skipMdsalUpdate = "N";
1890 if (failed(responseObject)) {
1891 responseBuilder.setResponseCode(responseObject.getStatusCode());
1892 responseBuilder.setResponseMessage(responseObject.getMessage());
1893 responseBuilder.setAckFinalIndicator(ackFinal);
1895 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1897 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1898 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1900 return Futures.immediateFuture(rpcResult);
1903 // Got success from SLI
1905 if (skipMdsalUpdate.equals("N")) {
1906 serviceData = serviceDataBuilder.build();
1907 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1910 ServiceBuilder serviceBuilder = new ServiceBuilder();
1911 serviceBuilder.setServiceData(serviceData);
1912 serviceBuilder.setServiceInstanceId(siid);
1913 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1914 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1916 trySaveService(input, serviceBuilder);
1918 // Even if we are skipping the MD-SAL update, update the service status object
1919 ServiceBuilder serviceBuilder = new ServiceBuilder();
1920 serviceBuilder.setServiceInstanceId(siid);
1921 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1922 Service service = serviceBuilder.build();
1923 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1924 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1927 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1928 networkResponseInformationBuilder.setInstanceId(networkId);
1929 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1930 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1932 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1933 serviceResponseInformationBuilder.setInstanceId(siid);
1934 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1935 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1936 } catch (IllegalStateException e) {
1937 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1938 responseBuilder.setResponseCode("500");
1939 responseBuilder.setResponseMessage(e.getMessage());
1940 responseBuilder.setAckFinalIndicator("Y");
1941 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1943 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1944 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1946 return Futures.immediateFuture(rpcResult);
1950 responseBuilder.setResponseCode(responseObject.getStatusCode());
1951 responseBuilder.setAckFinalIndicator(ackFinal);
1952 trySetResponseMessage(responseBuilder, responseObject);
1953 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1954 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1956 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1957 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1959 return Futures.immediateFuture(rpcResult);
1962 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1963 ResponseObject responseObject) {
1964 if (responseObject.getMessage() != null) {
1965 responseBuilder.setResponseMessage(responseObject.getMessage());
1969 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1970 NetworkTopologyOperationOutputBuilder responseBuilder) {
1971 if (input.getSdncRequestHeader() != null) {
1972 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1976 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1977 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1978 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1979 // Only update operational tree on Activate
1980 log.info(UPDATING_TREE_INFO_MESSAGE);
1981 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1985 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1986 return input == null || input.getServiceInformation() == null
1987 || input.getServiceInformation().getServiceInstanceId() == null
1988 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1991 private ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1992 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1994 responseBuilder.setResponseCode("404");
1995 responseBuilder.setResponseMessage(responseMessage);
1996 responseBuilder.setAckFinalIndicator("Y");
1998 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1999 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2001 return Futures.immediateFuture(rpcResult);
2004 private boolean isValidRequest(NetworkTopologyOperationInput input) {
2005 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2009 public ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
2010 ContrailRouteTopologyOperationInput input) {
2012 final String svcOperation = "contrail-route-topology-operation";
2013 ServiceData serviceData;
2014 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2015 Properties properties = new Properties();
2017 log.info(CALLED_STR, svcOperation);
2018 // create a new response object
2019 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
2021 if (hasInvalidServiceId(input)) {
2022 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2023 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
2026 String siid = input.getServiceInformation().getServiceInstanceId();
2028 // Get the service-instance service data from MD-SAL
2029 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2030 getServiceData(siid, serviceDataBuilder);
2032 trySetSvcRequestId(input, responseBuilder);
2034 ServiceData sd = serviceDataBuilder.build();
2035 if (isInvalidServiceData(sd)) {
2036 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2037 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2040 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
2041 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
2042 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2044 // Call SLI sync method
2046 ResponseObject responseObject = new ResponseObject("200", "");
2047 String ackFinal = "Y";
2048 String allottedResourceId = ERROR_NETWORK_ID;
2049 String serviceObjectPath = null;
2050 String contrailRouteObjectPath = null;
2051 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
2053 if (respProps != null) {
2054 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2055 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2056 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2057 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2058 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2059 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
2062 if (failed(responseObject)) {
2063 responseBuilder.setResponseCode(responseObject.getStatusCode());
2064 responseBuilder.setResponseMessage(responseObject.getMessage());
2065 responseBuilder.setAckFinalIndicator(ackFinal);
2066 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2068 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2069 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2071 return Futures.immediateFuture(rpcResult);
2074 // Got success from SLI
2076 serviceData = serviceDataBuilder.build();
2077 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2080 ServiceBuilder serviceBuilder = new ServiceBuilder();
2081 serviceBuilder.setServiceData(serviceData);
2082 serviceBuilder.setServiceInstanceId(siid);
2083 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2084 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2086 trySaveService(input, serviceBuilder);
2088 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
2089 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
2090 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
2091 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
2093 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2094 serviceResponseInformationBuilder.setInstanceId(siid);
2095 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2096 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2098 } catch (IllegalStateException e) {
2099 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2100 responseBuilder.setResponseCode("500");
2101 responseBuilder.setResponseMessage(e.getMessage());
2102 responseBuilder.setAckFinalIndicator("Y");
2103 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2105 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2106 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2108 return Futures.immediateFuture(rpcResult);
2112 responseBuilder.setResponseCode(responseObject.getStatusCode());
2113 responseBuilder.setAckFinalIndicator(ackFinal);
2114 trySetResponseMessage(responseBuilder, responseObject);
2115 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2116 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2118 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2119 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2121 return Futures.immediateFuture(rpcResult);
2124 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
2125 ResponseObject responseObject) {
2126 if (responseObject.getMessage() != null) {
2127 responseBuilder.setResponseMessage(responseObject.getMessage());
2131 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2132 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
2133 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2134 // Only update operational tree on activate or delete
2135 log.info(UPDATING_TREE_INFO_MESSAGE);
2136 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2140 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
2141 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
2142 if (input.getSdncRequestHeader() != null) {
2143 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2147 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
2148 return input == null || input.getServiceInformation() == null
2149 || input.getServiceInformation().getServiceInstanceId() == null
2150 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2153 private ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
2154 ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2155 responseBuilder.setResponseCode("404");
2156 responseBuilder.setResponseMessage(responseMessage);
2157 responseBuilder.setAckFinalIndicator("Y");
2159 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2160 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2162 return Futures.immediateFuture(rpcResult);
2165 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
2166 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2170 public ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
2171 SecurityZoneTopologyOperationInput input) {
2173 final String svcOperation = "security-zone-topology-operation";
2174 ServiceData serviceData;
2175 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2176 Properties parms = new Properties();
2178 log.info(CALLED_STR, svcOperation);
2179 // create a new response object
2180 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
2182 if (this.hasInvalidServiceId(input)) {
2183 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2184 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
2187 String siid = input.getServiceInformation().getServiceInstanceId();
2189 // Get the service-instance service data from MD-SAL
2190 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2191 getServiceData(siid, serviceDataBuilder);
2192 trySetSvcRequestId(input, responseBuilder);
2194 ServiceData sd = serviceDataBuilder.build();
2195 if (isInvalidServiceData(sd)) {
2196 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2197 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2200 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2201 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
2202 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2204 // Call SLI sync method
2206 Properties respProps = null;
2208 ResponseObject responseObject = new ResponseObject("200", "");
2209 String ackFinal = "Y";
2210 String allottedResourceId = ERROR_NETWORK_ID;
2211 String serviceObjectPath = null;
2212 String securityZoneObjectPath = null;
2215 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2218 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
2219 } catch (Exception e) {
2220 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2221 responseObject.setMessage(e.getMessage());
2222 responseObject.setStatusCode("500");
2225 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2226 responseObject.setStatusCode("503");
2228 } catch (Exception e) {
2229 responseObject.setStatusCode("500");
2230 responseObject.setMessage(e.getMessage());
2231 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2234 if (respProps != null) {
2235 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2236 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2237 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2238 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2239 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2240 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
2243 if (failed(responseObject)) {
2244 responseBuilder.setResponseCode(responseObject.getStatusCode());
2245 responseBuilder.setResponseMessage(responseObject.getMessage());
2246 responseBuilder.setAckFinalIndicator(ackFinal);
2247 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2249 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2250 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2252 return Futures.immediateFuture(rpcResult);
2255 // Got success from SLI
2258 serviceData = serviceDataBuilder.build();
2259 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2262 ServiceBuilder serviceBuilder = new ServiceBuilder();
2263 serviceBuilder.setServiceData(serviceData);
2264 serviceBuilder.setServiceInstanceId(siid);
2265 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2266 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2268 trySaveService(input, serviceBuilder);
2270 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
2271 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
2272 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
2273 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
2275 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2276 serviceResponseInformationBuilder.setInstanceId(siid);
2277 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2278 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2280 } catch (IllegalStateException e) {
2281 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2282 responseBuilder.setResponseCode("500");
2283 responseBuilder.setResponseMessage(e.getMessage());
2284 responseBuilder.setAckFinalIndicator("Y");
2285 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2287 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2288 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2290 return Futures.immediateFuture(rpcResult);
2294 responseBuilder.setResponseCode(responseObject.getStatusCode());
2295 responseBuilder.setAckFinalIndicator(ackFinal);
2296 trySetResponseMessage(responseBuilder, responseObject);
2297 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2298 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2300 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2301 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2303 return Futures.immediateFuture(rpcResult);
2306 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
2307 ResponseObject responseObject) {
2308 if (responseObject.getMessage() != null) {
2309 responseBuilder.setResponseMessage(responseObject.getMessage());
2313 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2314 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
2315 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2316 // Only update operational tree on activate or delete
2317 log.info(UPDATING_TREE_INFO_MESSAGE);
2318 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2322 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
2323 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
2324 if (input.getSdncRequestHeader() != null) {
2325 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2329 private boolean isInvalidServiceData(ServiceData sd) {
2330 return sd == null || sd.getServiceLevelOperStatus() == null;
2333 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
2334 return input == null || input.getServiceInformation() == null
2335 || input.getServiceInformation().getServiceInstanceId() == null
2336 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2339 private ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
2340 SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2342 responseBuilder.setResponseCode("404");
2343 responseBuilder.setResponseMessage(responseMessage);
2344 responseBuilder.setAckFinalIndicator("Y");
2346 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2347 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2349 return Futures.immediateFuture(rpcResult);
2352 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
2353 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2357 private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
2358 return input == null || input.getServiceInformation() == null
2359 || input.getServiceInformation().getServiceInstanceId() == null
2360 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2363 private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
2364 ResponseObject error) {
2365 if (!error.getMessage().isEmpty()) {
2366 responseBuilder.setResponseMessage(error.getMessage());
2370 private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
2371 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
2372 if (input.getSdncRequestHeader() != null) {
2373 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2377 private ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
2378 buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2380 responseBuilder.setResponseCode("404");
2381 responseBuilder.setResponseMessage(responseMessage);
2382 responseBuilder.setAckFinalIndicator("Y");
2384 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2385 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2386 .withResult(responseBuilder.build())
2389 return Futures.immediateFuture(rpcResult);
2392 private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2393 if (isValidRequest(input) &&
2394 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
2395 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2396 // Only update operational tree on activate or delete
2397 log.info(UPDATING_TREE_INFO_MESSAGE);
2398 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2402 private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
2403 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2407 public ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(
2408 ConnectionAttachmentTopologyOperationInput input) {
2409 final String svcOperation = "connection-attachment-topology-operation";
2410 Properties parms = new Properties();
2411 log.info(CALLED_STR, svcOperation);
2413 // create a new response object
2414 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
2415 if (hasInvalidServiceId(input)) {
2416 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2417 responseBuilder.setResponseCode("404");
2418 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2419 responseBuilder.setAckFinalIndicator("Y");
2421 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2422 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2423 .withResult(responseBuilder.build())
2426 return Futures.immediateFuture(rpcResult);
2429 ServiceData serviceData;
2430 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2432 String siid = input.getServiceInformation().getServiceInstanceId();
2433 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2435 // Get the service-instance service data from MD-SAL
2436 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2437 getServiceData(siid, serviceDataBuilder);
2439 trySetSvcRequestId(input, responseBuilder);
2441 ServiceData sd = serviceDataBuilder.build();
2442 if (isInvalidServiceData(sd)) {
2443 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2444 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2447 ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(
2449 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2451 // Call SLI sync method
2452 // Get SvcLogicService reference
2453 ResponseObject responseObject = new ResponseObject("200", "");
2454 String ackFinal = "Y";
2455 String allottedResourceId = ERROR_NETWORK_ID;
2456 String serviceObjectPath = null;
2457 String connectionAttachmentObjectPath = null;
2459 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2461 if (respProps != null) {
2462 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2463 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2464 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2465 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2466 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2467 connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
2470 if (failed(responseObject)) {
2471 responseBuilder.setResponseCode(responseObject.getStatusCode());
2472 responseBuilder.setResponseMessage(responseObject.getMessage());
2473 responseBuilder.setAckFinalIndicator(ackFinal);
2475 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2477 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2478 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2479 .withResult(responseBuilder.build())
2482 return Futures.immediateFuture(rpcResult);
2485 // Got success from SLI
2488 serviceData = serviceDataBuilder.build();
2489 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2492 ServiceBuilder serviceBuilder = new ServiceBuilder();
2493 serviceBuilder.setServiceData(serviceData);
2494 serviceBuilder.setServiceInstanceId(siid);
2495 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2496 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2498 trySaveService(input, serviceBuilder);
2500 ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
2501 connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
2502 connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
2504 .setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
2506 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2507 serviceResponseInformationBuilder.setInstanceId(siid);
2508 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2509 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2511 } catch (IllegalStateException e) {
2512 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2513 responseBuilder.setResponseCode("500");
2514 responseBuilder.setResponseMessage(e.getMessage());
2515 responseBuilder.setAckFinalIndicator("Y");
2516 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2518 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2519 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2520 .withResult(responseBuilder.build())
2523 return Futures.immediateFuture(rpcResult);
2527 responseBuilder.setResponseCode(responseObject.getStatusCode());
2528 responseBuilder.setAckFinalIndicator(ackFinal);
2529 trySetResponseMessage(responseBuilder, responseObject);
2530 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2531 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2533 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2534 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2535 .withResult(responseBuilder.build())
2538 return Futures.immediateFuture(rpcResult);
2542 public ListenableFuture<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
2543 TunnelxconnTopologyOperationInput input) {
2545 final String svcOperation = "tunnelxconn-topology-operation";
2546 Properties parms = new Properties();
2547 log.info(CALLED_STR, svcOperation);
2549 // create a new response object
2550 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
2551 if (hasInvalidServiceId(input)) {
2552 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2553 responseBuilder.setResponseCode("404");
2554 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2555 responseBuilder.setAckFinalIndicator("Y");
2557 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2558 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2560 return Futures.immediateFuture(rpcResult);
2562 String siid = input.getServiceInformation().getServiceInstanceId();
2563 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2564 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
2565 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2567 // Call SLI sync method
2569 ResponseObject responseObject = new ResponseObject("200", "");
2570 String ackFinal = "Y";
2571 String allottedResourceId = ERROR_NETWORK_ID;
2572 String serviceObjectPath = null;
2573 String tunnelxconnObjectPath = null;
2574 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2576 if (respProps != null) {
2577 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2578 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2579 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2580 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2581 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2582 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
2585 if (failed(responseObject)) {
2586 responseBuilder.setResponseCode(responseObject.getStatusCode());
2587 responseBuilder.setResponseMessage(responseObject.getMessage());
2588 responseBuilder.setAckFinalIndicator(ackFinal);
2590 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2592 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2593 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2595 return Futures.immediateFuture(rpcResult);
2598 // Got success from SLI
2600 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
2601 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
2602 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
2603 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
2605 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2606 serviceResponseInformationBuilder.setInstanceId(siid);
2607 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2608 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2610 } catch (IllegalStateException e) {
2611 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2612 responseBuilder.setResponseCode("500");
2613 responseBuilder.setResponseMessage(e.getMessage());
2614 responseBuilder.setAckFinalIndicator("Y");
2615 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2617 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2618 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2620 return Futures.immediateFuture(rpcResult);
2624 responseBuilder.setResponseCode(responseObject.getStatusCode());
2625 responseBuilder.setAckFinalIndicator(ackFinal);
2626 trySetResponseMessage(responseBuilder, responseObject);
2627 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2628 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2630 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2631 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2633 return Futures.immediateFuture(rpcResult);
2636 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2637 ResponseObject responseObject) {
2638 if (responseObject.getMessage() != null) {
2639 responseBuilder.setResponseMessage(responseObject.getMessage());
2643 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2644 return input == null || input.getServiceInformation() == null
2645 || input.getServiceInformation().getServiceInstanceId() == null
2646 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2649 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2651 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2654 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2655 } catch (Exception e) {
2656 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2657 responseObject.setMessage(e.getMessage());
2658 responseObject.setStatusCode("500");
2661 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2662 responseObject.setStatusCode("503");
2664 } catch (Exception e) {
2665 responseObject.setMessage(e.getMessage());
2666 responseObject.setStatusCode("500");
2667 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2673 public ListenableFuture<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(
2674 BrgTopologyOperationInput input) {
2675 final String svcOperation = "brg-topology-operation";
2676 Properties parms = new Properties();
2678 log.info(CALLED_STR, svcOperation);
2679 // create a new response object
2680 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2682 if (this.hasInvalidServiceId(input)) {
2684 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2685 responseBuilder.setResponseCode("404");
2686 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2687 responseBuilder.setAckFinalIndicator("Y");
2689 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2690 .withResult(responseBuilder.build()).build();
2692 return Futures.immediateFuture(rpcResult);
2695 String siid = input.getServiceInformation().getServiceInstanceId();
2697 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2698 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2699 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2701 // Call SLI sync method
2703 ResponseObject responseObject = new ResponseObject("200", "");
2704 String ackFinal = "Y";
2705 String allottedResourceId = ERROR_NETWORK_ID;
2706 String serviceObjectPath = null;
2707 String brgObjectPath = null;
2708 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2710 if (respProps != null) {
2711 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2712 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2713 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2714 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2715 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2716 brgObjectPath = respProps.getProperty("brg-object-path");
2719 if (failed(responseObject)) {
2720 responseBuilder.setResponseCode(responseObject.getStatusCode());
2721 responseBuilder.setResponseMessage(responseObject.getMessage());
2722 responseBuilder.setAckFinalIndicator(ackFinal);
2724 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2725 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2726 .withResult(responseBuilder.build()).build();
2728 return Futures.immediateFuture(rpcResult);
2731 // Got success from SLI
2734 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2735 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2736 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2737 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2739 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2740 serviceResponseInformationBuilder.setInstanceId(siid);
2741 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2742 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2744 } catch (IllegalStateException e) {
2745 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2746 responseBuilder.setResponseCode("500");
2747 responseBuilder.setResponseMessage(e.getMessage());
2748 responseBuilder.setAckFinalIndicator("Y");
2749 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2751 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2752 .withResult(responseBuilder.build()).build();
2754 return Futures.immediateFuture(rpcResult);
2758 responseBuilder.setResponseCode(responseObject.getStatusCode());
2759 responseBuilder.setAckFinalIndicator(ackFinal);
2760 trySetResponseMessage(responseBuilder, responseObject);
2761 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2762 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2764 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2765 .withResult(responseBuilder.build()).build();
2767 return Futures.immediateFuture(rpcResult);
2770 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2771 ResponseObject responseObject) {
2772 if (responseObject.getMessage() != null) {
2773 responseBuilder.setResponseMessage(responseObject.getMessage());
2777 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2778 return input == null || input.getServiceInformation() == null
2779 || input.getServiceInformation().getServiceInstanceId() == null
2780 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2783 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2784 if (respProps != null) {
2785 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2786 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2787 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2793 public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2794 PreloadNetworkTopologyOperationInput input) {
2796 final String svcOperation = "preload-network-topology-operation";
2797 PreloadData preloadData;
2798 Properties properties = new Properties();
2800 log.info(CALLED_STR, svcOperation);
2801 // create a new response object
2802 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2804 if (hasInvalidPreloadNetwork(input)) {
2805 log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2806 responseBuilder.setResponseCode("403");
2807 responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2808 responseBuilder.setAckFinalIndicator("Y");
2810 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2811 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2813 return Futures.immediateFuture(rpcResult);
2816 // Grab the preload ID from the input buffer
2817 String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2819 String preloadType = "network";
2821 trySetSvcRequestId(input, responseBuilder);
2823 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2824 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2826 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2827 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2830 // setup a preload-data object builder
2831 // ACTION preload-network-topology-operation
2833 // uses sdnc-request-header;
2834 // uses request-information;
2835 // uses preload-network-topology-information;
2837 // uses preload-topology-response-body;
2839 // container preload-data
2840 // uses preload-network-topology-information;
2841 // uses preload-oper-status;
2843 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2844 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2846 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2847 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2848 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2850 // Call SLI sync method
2851 ResponseObject responseObject = new ResponseObject("200", "");
2852 String ackFinal = "Y";
2853 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2855 if (respProps != null) {
2856 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2857 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2858 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2861 if (failed(responseObject)) {
2862 responseBuilder.setResponseCode(responseObject.getStatusCode());
2863 responseBuilder.setResponseMessage(responseObject.getMessage());
2864 responseBuilder.setAckFinalIndicator(ackFinal);
2865 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2866 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2867 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2868 return Futures.immediateFuture(rpcResult);
2871 // Got success from SLI
2873 preloadData = preloadDataBuilder.build();
2874 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2876 // preload-list object
2877 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2878 preloadListBuilder.setPreloadId(preloadId);
2879 preloadListBuilder.setPreloadType(preloadType);
2880 preloadListBuilder.setPreloadData(preloadData);
2882 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2883 log.info(UPDATING_TREE_INFO_MESSAGE);
2884 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2886 tryDeletePreload(input, preloadListBuilder);
2887 } catch (Exception e) {
2888 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2889 responseBuilder.setResponseCode("500");
2890 responseBuilder.setResponseMessage(e.getMessage());
2891 responseBuilder.setAckFinalIndicator("Y");
2892 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2893 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2894 .<PreloadNetworkTopologyOperationOutput>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, preloadId);
2903 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2905 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2906 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2907 return Futures.immediateFuture(rpcResult);
2910 private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2911 return input == null || input.getPreloadNetworkTopologyInformation() == null
2912 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2915 private boolean hasInvalidPreloadId(String preloadId) {
2916 return preloadId == null || preloadId.length() == 0;
2919 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2920 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2921 if (input.getSdncRequestHeader() != null) {
2922 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2926 private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2927 ResponseObject responseObject) {
2929 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2931 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2932 } catch (Exception e) {
2933 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2934 responseObject.setMessage(e.getMessage());
2935 responseObject.setStatusCode("500");
2938 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2939 responseObject.setStatusCode("503");
2941 } catch (Exception e) {
2942 responseObject.setMessage(e.getMessage());
2943 responseObject.setStatusCode("500");
2944 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2950 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2951 ResponseObject responseObject) {
2952 if (responseObject.getMessage() != null) {
2953 if (!responseObject.getMessage().isEmpty()) {
2954 responseBuilder.setResponseMessage(responseObject.getMessage());
2959 private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2960 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2961 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2962 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2963 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2968 public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2969 PreloadVfModuleTopologyOperationInput input) {
2971 final String svcOperation = "preload-vf-module-topology-operation";
2972 PreloadData preloadData;
2973 Properties properties = new Properties();
2975 log.info(CALLED_STR, svcOperation);
2976 // create a new response object
2977 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2979 if (hasInvalidPreloadVfModule(input)) {
2981 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2983 responseBuilder.setResponseCode("403");
2984 responseBuilder.setResponseMessage(
2985 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2986 responseBuilder.setAckFinalIndicator("Y");
2988 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2989 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2991 return Futures.immediateFuture(rpcResult);
2994 // Grab the preload ID from the input buffer
2995 String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2996 .getVfModuleTopologyIdentifier().getVfModuleName();
2997 String preloadType = "vf-module";
2999 trySetSvcRequestId(input, responseBuilder);
3001 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
3002 getPreloadData(preloadId, preloadType, preloadDataBuilder);
3004 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
3005 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3008 // setup a preload-data object builder
3009 // ACTION preload-vf-module-topology-operation
3011 // uses sdnc-request-header;
3012 // uses request-information;
3013 // uses preload-vnf-topology-information;
3015 // uses preload-topology-response-body;
3017 // container preload-data
3018 // uses preload-vf-module-topology-information;
3019 // uses preload-oper-status;
3021 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
3022 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
3024 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3025 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
3026 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3028 // Call SLI sync method
3029 ResponseObject responseObject = new ResponseObject("200", "");
3030 String ackFinal = "Y";
3031 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
3033 if (respProps != null) {
3034 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3035 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3036 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3039 if (failed(responseObject)) {
3040 responseBuilder.setResponseCode(responseObject.getStatusCode());
3041 responseBuilder.setResponseMessage(responseObject.getMessage());
3042 responseBuilder.setAckFinalIndicator(ackFinal);
3043 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
3044 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
3045 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3046 return Futures.immediateFuture(rpcResult);
3049 // Got success from SLI
3051 preloadData = preloadDataBuilder.build();
3052 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
3054 // preload-list object
3055 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
3056 preloadListBuilder.setPreloadId(preloadId);
3057 preloadListBuilder.setPreloadType(preloadType);
3058 preloadListBuilder.setPreloadData(preloadData);
3060 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3061 log.info(UPDATING_TREE_INFO_MESSAGE);
3062 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3064 tryDeletePreload(input, preloadListBuilder);
3066 } catch (Exception e) {
3067 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
3068 responseBuilder.setResponseCode("500");
3069 responseBuilder.setResponseMessage(e.getMessage());
3070 responseBuilder.setAckFinalIndicator("Y");
3071 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
3072 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
3073 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3074 return Futures.immediateFuture(rpcResult);
3078 responseBuilder.setResponseCode(responseObject.getStatusCode());
3079 responseBuilder.setAckFinalIndicator(ackFinal);
3080 trySetResponseMessage(responseBuilder, responseObject);
3081 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
3082 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
3084 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
3085 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3086 return Futures.immediateFuture(rpcResult);
3089 private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
3090 return input == null || input.getPreloadVfModuleTopologyInformation() == null
3091 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
3092 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
3093 .getVfModuleTopologyIdentifier() == null
3094 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
3095 .getVfModuleName() == null;
3098 private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
3099 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
3100 if (input.getSdncRequestHeader() != null) {
3101 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3105 private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
3106 ResponseObject responseObject) {
3107 if (responseObject.getMessage() != null) {
3108 if (!responseObject.getMessage().isEmpty()) {
3109 responseBuilder.setResponseMessage(responseObject.getMessage());
3114 private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
3115 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
3116 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
3117 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
3118 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
3123 public ListenableFuture<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
3124 GenericConfigurationTopologyOperationInput input) {
3126 final String svcOperation = "generic-configuration-topology-operation";
3127 ServiceData serviceData;
3128 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3129 Properties parms = new Properties();
3131 log.info(CALLED_STR, svcOperation);
3132 // create a new response object
3133 GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
3135 if (hasInvalidService(input)) {
3136 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3137 responseBuilder.setResponseCode("404");
3138 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3139 responseBuilder.setAckFinalIndicator("Y");
3141 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3142 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3145 return Futures.immediateFuture(rpcResult);
3148 // Grab the service instance ID from the input buffer
3149 String siid = input.getServiceInformation().getServiceInstanceId();
3151 trySetSvcRequestId(input, responseBuilder);
3153 if (hasInvalidConfigurationIdOrType(input)) {
3154 log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
3155 responseBuilder.setResponseCode("404");
3156 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
3157 responseBuilder.setAckFinalIndicator("Y");
3158 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3159 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3161 return Futures.immediateFuture(rpcResult);
3164 // Grab the configuration ID from the input buffer
3165 String configId = input.getConfigurationInformation().getConfigurationId();
3167 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3168 getServiceData(siid, serviceDataBuilder);
3170 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3171 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3173 // Set the serviceStatus based on input
3174 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3175 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3177 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3178 GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
3180 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3182 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3183 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3185 // Call SLI sync method
3187 ResponseObject responseObject = new ResponseObject("200", "");
3188 String ackFinal = "Y";
3189 String serviceObjectPath = "";
3190 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3192 if (respProps != null) {
3193 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3194 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3195 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3196 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3199 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3200 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3201 serviceStatusBuilder.setRpcName(svcOperation);
3203 if (failed(responseObject)) {
3204 responseBuilder.setResponseCode(responseObject.getStatusCode());
3205 responseBuilder.setResponseMessage(responseObject.getMessage());
3206 responseBuilder.setAckFinalIndicator(ackFinal);
3208 ServiceBuilder serviceBuilder = new ServiceBuilder();
3209 serviceBuilder.setServiceInstanceId(siid);
3210 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3212 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3213 } catch (Exception e) {
3214 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3216 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3218 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3219 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3222 return Futures.immediateFuture(rpcResult);
3225 // Got success from SLI
3227 serviceData = serviceDataBuilder.build();
3230 ServiceBuilder serviceBuilder = new ServiceBuilder();
3231 serviceBuilder.setServiceData(serviceData);
3232 serviceBuilder.setServiceInstanceId(siid);
3233 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3234 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3236 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3237 serviceResponseInformationBuilder.setInstanceId(siid);
3238 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3239 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3240 GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
3241 gcResponseInformationBuilder.setInstanceId(configId);
3242 responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
3244 } catch (Exception e) {
3245 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3246 responseBuilder.setResponseCode("500");
3247 responseBuilder.setResponseMessage(e.getMessage());
3248 responseBuilder.setAckFinalIndicator("Y");
3249 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3250 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3253 return Futures.immediateFuture(rpcResult);
3257 responseBuilder.setResponseCode(responseObject.getStatusCode());
3258 responseBuilder.setAckFinalIndicator(ackFinal);
3259 trySetResponseMessage(responseBuilder, responseObject);
3260 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3261 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3263 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3264 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3266 return Futures.immediateFuture(rpcResult);
3269 private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
3270 return input == null || input.getServiceInformation() == null
3271 || input.getServiceInformation().getServiceInstanceId() == null
3272 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3275 private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
3276 GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
3277 if (input.getSdncRequestHeader() != null) {
3278 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3282 private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
3283 return input.getConfigurationInformation() == null
3284 || input.getConfigurationInformation().getConfigurationId() == null
3285 || input.getConfigurationInformation().getConfigurationType() == null;
3288 private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
3289 ResponseObject responseObject) {
3290 if (responseObject.getMessage() != null) {
3291 if (!responseObject.getMessage().isEmpty()) {
3292 responseBuilder.setResponseMessage(responseObject.getMessage());
3298 public ListenableFuture<RpcResult<GenericConfigurationNotificationOutput>> genericConfigurationNotification(
3299 GenericConfigurationNotificationInput input) {
3301 final String svcOperation = "generic-configuration-notification";
3302 ServiceData serviceData;
3303 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3304 Properties parms = new Properties();
3306 log.info(CALLED_STR, svcOperation);
3308 // Grab the service instance ID from the input buffer
3309 String siid = input.getServiceInformation().getServiceInstanceId();
3311 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3312 getServiceData(siid, serviceDataBuilder);
3314 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3315 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3317 // Set the serviceStatus based on input
3318 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3319 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3321 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3322 GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
3324 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3326 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3327 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3329 // Call SLI sync method
3331 ResponseObject responseObject = new ResponseObject("200", "");
3332 String ackFinal = "Y";
3333 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3335 if (respProps != null) {
3336 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3337 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3338 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3341 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3342 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3343 serviceStatusBuilder.setRpcName(svcOperation);
3345 if (failed(responseObject)) {
3346 ServiceBuilder serviceBuilder = new ServiceBuilder();
3347 serviceBuilder.setServiceInstanceId(siid);
3348 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3350 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3351 } catch (Exception e) {
3352 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3355 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3358 return Futures.immediateFuture(rpcResult);
3361 // Got success from SLI
3363 serviceData = serviceDataBuilder.build();
3366 ServiceBuilder serviceBuilder = new ServiceBuilder();
3367 serviceBuilder.setServiceData(serviceData);
3368 serviceBuilder.setServiceInstanceId(siid);
3369 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3370 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3372 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3373 serviceResponseInformationBuilder.setInstanceId(siid);
3375 } catch (Exception e) {
3376 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3377 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3380 return Futures.immediateFuture(rpcResult);
3384 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3386 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3389 return Futures.immediateFuture(rpcResult);
3393 public ListenableFuture<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
3394 GetpathsegmentTopologyOperationInput input) {
3396 final String svcOperation = "getpathsegment-topology-operation";
3397 ServiceData serviceData;
3398 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3399 Properties parms = new Properties();
3401 log.info(CALLED_STR, svcOperation);
3402 // create a new response object
3403 GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
3405 if (hasInvalidService(input)) {
3406 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3407 responseBuilder.setResponseCode("404");
3408 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3409 responseBuilder.setAckFinalIndicator("Y");
3411 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3412 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3414 return Futures.immediateFuture(rpcResult);
3417 // Grab the service instance ID from the input buffer
3418 String siid = input.getServiceInformation().getServiceInstanceId();
3420 trySetSvcRequestId(input, responseBuilder);
3422 if (hasInvalidOnapModelInformation(input)) {
3423 log.debug("exiting {} because no model-uuid provided", svcOperation);
3424 responseBuilder.setResponseCode("404");
3425 responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
3426 responseBuilder.setAckFinalIndicator("Y");
3427 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3428 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3429 return Futures.immediateFuture(rpcResult);
3432 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3433 getServiceData(siid, serviceDataBuilder);
3435 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3436 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3438 // Set the serviceStatus based on input
3439 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3440 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3442 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3443 GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
3445 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3447 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3448 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3450 // Call SLI sync method
3452 ResponseObject responseObject = new ResponseObject("200", "");
3453 String ackFinal = "Y";
3454 String serviceObjectPath = null;
3455 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3457 if (respProps != null) {
3458 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3459 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3460 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3461 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3464 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3465 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3466 serviceStatusBuilder.setRpcName(svcOperation);
3468 if (failed(responseObject)) {
3469 responseBuilder.setResponseCode(responseObject.getStatusCode());
3470 responseBuilder.setResponseMessage(responseObject.getMessage());
3471 responseBuilder.setAckFinalIndicator(ackFinal);
3473 ServiceBuilder serviceBuilder = new ServiceBuilder();
3474 serviceBuilder.setServiceInstanceId(siid);
3475 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3477 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3478 } catch (Exception e) {
3479 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3481 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3483 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3484 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3486 return Futures.immediateFuture(rpcResult);
3489 // Got success from SLI
3491 serviceData = serviceDataBuilder.build();
3492 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3495 ServiceBuilder serviceBuilder = new ServiceBuilder();
3496 serviceBuilder.setServiceData(serviceData);
3497 serviceBuilder.setServiceInstanceId(siid);
3498 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3499 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3501 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3502 serviceResponseInformationBuilder.setInstanceId(siid);
3503 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3504 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3506 } catch (Exception e) {
3507 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3508 responseBuilder.setResponseCode("500");
3509 responseBuilder.setResponseMessage(e.getMessage());
3510 responseBuilder.setAckFinalIndicator("Y");
3511 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3512 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3514 return Futures.immediateFuture(rpcResult);
3518 responseBuilder.setResponseCode(responseObject.getStatusCode());
3519 responseBuilder.setAckFinalIndicator(ackFinal);
3520 trySetResponseMessage(responseBuilder, responseObject);
3521 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3522 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3524 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3525 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3527 return Futures.immediateFuture(rpcResult);
3530 private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
3531 return input == null || input.getServiceInformation() == null
3532 || input.getServiceInformation().getServiceInstanceId() == null
3533 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3536 private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
3537 GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
3538 if (input.getSdncRequestHeader() != null) {
3539 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3543 private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
3544 return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
3545 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
3548 private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
3549 ResponseObject responseObject) {
3550 if (responseObject.getMessage() != null) {
3551 if (!responseObject.getMessage().isEmpty()) {
3552 responseBuilder.setResponseMessage(responseObject.getMessage());
3558 public ListenableFuture<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
3559 PolicyUpdateNotifyOperationInput input) {
3561 final String svcOperation = "policy-update-notify-operation";
3562 Properties parms = new Properties();
3564 log.info(CALLED_STR, svcOperation);
3566 // create a new response object
3567 PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
3569 // Make sure we have a valid input
3570 if (hasInvalidInput(input)) {
3571 log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
3572 responseBuilder.setErrorCode("404");
3573 responseBuilder.setErrorMsg("Invalid input, missing input data");
3574 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3575 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3576 return Futures.immediateFuture(rpcResult);
3579 log.info("Adding INPUT data for {} input: {}", svcOperation, input);
3580 PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
3581 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3583 // Call SLI sync method
3584 ResponseObject responseObject = new ResponseObject("200", "");
3585 String ackFinal = "Y";
3586 String serviceObjectPath = null;
3587 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
3589 if (respProps != null) {
3590 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3591 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3592 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3593 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3596 if (failed(responseObject)) {
3597 responseBuilder.setErrorCode(responseObject.getStatusCode());
3598 responseBuilder.setErrorMsg(responseObject.getMessage());
3599 log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
3601 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3602 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3604 return Futures.immediateFuture(rpcResult);
3607 // Got success from SLI
3608 responseBuilder.setErrorCode(responseObject.getStatusCode());
3609 if (responseObject.getMessage() != null) {
3610 responseBuilder.setErrorMsg(responseObject.getMessage());
3612 log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
3613 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3614 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3616 return Futures.immediateFuture(rpcResult);
3619 private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
3620 return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3624 public ListenableFuture<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3625 final PortMirrorTopologyOperationInput input) {
3627 final String svcOperation = "port-mirror-topology-operation";
3628 ServiceData serviceData = null;
3629 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3630 Properties properties = new Properties();
3632 log.info(CALLED_STR, svcOperation);
3634 // create a new response object
3635 PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3637 if (hasInvalidService(input)) {
3638 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3639 responseBuilder.setResponseCode("404");
3640 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3641 responseBuilder.setAckFinalIndicator("Y");
3642 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3643 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3645 return Futures.immediateFuture(rpcResult);
3648 if (hasInvalidConfigurationId(input)) {
3649 log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3650 responseBuilder.setResponseCode("404");
3651 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3652 responseBuilder.setAckFinalIndicator("Y");
3653 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3654 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3655 return Futures.immediateFuture(rpcResult);
3658 // Grab the service instance ID from the input buffer
3659 String siid = input.getServiceInformation().getServiceInstanceId();
3661 trySetSvcRequestId(input, responseBuilder);
3663 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3664 getServiceData(siid, serviceDataBuilder);
3666 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3667 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3669 // Set the serviceStatus based on input
3670 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3671 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3673 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3674 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3675 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3677 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3678 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3680 // Call SLI sync method
3681 ResponseObject responseObject = new ResponseObject("200", "");
3682 String ackFinal = "Y";
3683 String serviceObjectPath = null;
3684 String portMirrorObjectPath = null;
3685 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3687 if (respProps != null) {
3688 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3689 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3690 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3691 serviceObjectPath = respProps.getProperty("service-object-path");
3692 portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3695 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3696 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3697 serviceStatusBuilder.setRpcName(svcOperation);
3699 if (failed(responseObject)) {
3700 responseBuilder.setResponseCode(responseObject.getStatusCode());
3701 responseBuilder.setResponseMessage(responseObject.getMessage());
3702 responseBuilder.setAckFinalIndicator(ackFinal);
3704 ServiceBuilder serviceBuilder = new ServiceBuilder();
3705 serviceBuilder.setServiceInstanceId(siid);
3706 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3708 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3709 } catch (Exception e) {
3710 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3712 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3714 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3715 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3718 return Futures.immediateFuture(rpcResult);
3721 // Got success from SLI
3723 serviceData = serviceDataBuilder.build();
3724 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3727 ServiceBuilder serviceBuilder = new ServiceBuilder();
3728 serviceBuilder.setServiceData(serviceData);
3729 serviceBuilder.setServiceInstanceId(siid);
3730 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3731 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3733 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3734 // Only update operational tree on activate or delete
3735 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3736 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3737 log.info(UPDATING_TREE_INFO_MESSAGE);
3738 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3742 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3743 serviceResponseInformationBuilder.setInstanceId(siid);
3744 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3745 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3746 PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3747 portMirrorResponseInformationBuilder
3748 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3749 portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3750 responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3752 } catch (Exception e) {
3753 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3754 responseBuilder.setResponseCode("500");
3755 responseBuilder.setResponseMessage(e.getMessage());
3756 responseBuilder.setAckFinalIndicator("Y");
3757 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3758 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3759 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3760 return Futures.immediateFuture(rpcResult);
3764 responseBuilder.setResponseCode(responseObject.getStatusCode());
3765 responseBuilder.setAckFinalIndicator(ackFinal);
3766 trySetResponseMessage(responseBuilder, responseObject);
3767 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3768 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3770 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3771 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3773 if (ackFinal.equals("N")) {
3774 // Spawn background thread to invoke the Async DG
3775 Runnable backgroundThread = new Runnable() {
3777 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3778 processAsyncPortMirrorTopologyOperation(input);
3781 new Thread(backgroundThread).start();
3785 return Futures.immediateFuture(rpcResult);
3788 private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3789 return input == null || input.getServiceInformation() == null
3790 || input.getServiceInformation().getServiceInstanceId() == null
3791 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3794 private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3795 return input.getConfigurationInformation() == null
3796 || input.getConfigurationInformation().getConfigurationId() == null
3797 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3800 private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3801 PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3802 if (input.getSdncRequestHeader() != null) {
3803 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3807 private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3808 ResponseObject responseObject) {
3809 if (responseObject.getMessage() != null) {
3810 if (!responseObject.getMessage().isEmpty()) {
3811 responseBuilder.setResponseMessage(responseObject.getMessage());
3816 public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3817 log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3819 final String svcOperation = "port-mirror-topology-operation-async";
3820 ServiceData serviceData = null;
3821 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3822 Properties parms = new Properties();
3824 log.info(CALLED_STR, svcOperation);
3826 // Grab the service instance ID from the input buffer
3827 String siid = input.getServiceInformation().getServiceInstanceId();
3829 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3830 getServiceData(siid, serviceDataBuilder);
3832 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3833 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3835 // Set the serviceStatus based on input
3836 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3837 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3839 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3840 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3841 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3843 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3844 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3846 // Call SLI sync method
3847 ResponseObject responseObject = new ResponseObject("200", "");
3848 String ackFinal = "Y";
3849 String serviceObjectPath = null;
3850 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3852 if (respProps != null) {
3853 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3854 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3855 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3858 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3859 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3860 serviceStatusBuilder.setRpcName(svcOperation);
3862 if (failed(responseObject)) {
3863 ServiceBuilder serviceBuilder = new ServiceBuilder();
3864 serviceBuilder.setServiceInstanceId(siid);
3865 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3867 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3868 } catch (Exception e) {
3869 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3876 // Got success from SLI
3878 serviceData = serviceDataBuilder.build();
3879 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3882 ServiceBuilder serviceBuilder = new ServiceBuilder();
3883 serviceBuilder.setServiceData(serviceData);
3884 serviceBuilder.setServiceInstanceId(siid);
3885 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3886 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3888 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3889 // Only update operational tree on activate or delete
3890 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3891 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3892 log.info(UPDATING_TREE_INFO_MESSAGE);
3893 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3897 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3898 serviceResponseInformationBuilder.setInstanceId(siid);
3899 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3901 } catch (Exception e) {
3902 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3907 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3913 public ListenableFuture<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(
3914 VnfGetResourceRequestInput input) {
3916 final String svcOperation = "vnf-get-resource-request";
3917 ServiceData serviceData;
3918 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3919 Properties parms = new Properties();
3921 log.info(CALLED_STR, svcOperation);
3922 // create a new response object
3923 VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3925 if (hasInvalidService(input)) {
3926 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3927 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3928 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3930 return Futures.immediateFuture(rpcResult);
3933 // Grab the service instance ID from the input buffer
3934 String siid = input.getServiceInformation().getServiceInstanceId();
3936 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3937 getServiceData(siid, serviceDataBuilder);
3939 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3940 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3942 // Set the serviceStatus based on input
3943 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3944 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3946 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3947 VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3948 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3950 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3951 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3953 // Call SLI sync method
3955 ResponseObject responseObject = new ResponseObject("200", "");
3956 String ackFinal = "Y";
3957 String serviceObjectPath = null;
3958 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3960 if (respProps != null) {
3961 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3962 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3963 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3964 serviceObjectPath = respProps.getProperty("service-object-path");
3967 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3968 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3969 serviceStatusBuilder.setRpcName(svcOperation);
3971 if (failed(responseObject)) {
3972 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3973 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3974 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3976 return Futures.immediateFuture(rpcResult);
3979 // Got success from SLI
3980 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3982 if (respProps != null) {
3983 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3986 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3987 .withResult(responseBuilder.build()).build();
3990 return Futures.immediateFuture(rpcResult);
3993 private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3994 return input == null || input.getServiceInformation() == null
3995 || input.getServiceInformation().getServiceInstanceId() == null
3996 || input.getServiceInformation().getServiceInstanceId().length() == 0;