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 {}";
210 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
211 private final ExecutorService executor;
212 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
214 protected DataBroker dataBroker;
215 protected NotificationPublishService notificationService;
216 protected RpcProviderRegistry rpcRegistry;
217 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
219 public GenericResourceApiProvider(DataBroker dataBroker, NotificationPublishService notificationPublishService,
220 RpcProviderRegistry rpcProviderRegistry, GenericResourceApiSvcLogicServiceClient client) {
221 log.info("Creating provider for {}", APP_NAME);
222 executor = Executors.newFixedThreadPool(1);
223 setDataBroker(dataBroker);
224 setNotificationService(notificationPublishService);
225 setRpcRegistry(rpcProviderRegistry);
226 svcLogicClient = client;
231 public void initialize() {
232 log.info("Initializing provider for {}", APP_NAME);
233 // Create the top level containers
236 GenericResourceApiUtil.loadProperties();
237 } catch (Exception e) {
238 log.error("Caught Exception while trying to load properties file", e);
241 log.info("Initialization complete for {}", APP_NAME);
244 protected void initializeChild() {
245 // Override if you have custom initialization intelligence
249 public void close() throws Exception {
250 log.info("Closing provider for {}", APP_NAME);
252 rpcRegistration.close();
253 log.info("Successfully closed provider for {}", APP_NAME);
256 private static class Iso8601Util {
258 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
259 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
261 private Iso8601Util() {
265 dateFormat.setTimeZone(timeZone);
268 private static String now() {
269 return dateFormat.format(new Date());
273 public void setDataBroker(DataBroker dataBroker) {
274 this.dataBroker = dataBroker;
275 if (log.isDebugEnabled()) {
276 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
280 public void setNotificationService(NotificationPublishService notificationService) {
281 this.notificationService = notificationService;
282 if (log.isDebugEnabled()) {
283 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
287 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
288 this.rpcRegistry = rpcRegistry;
289 if (log.isDebugEnabled()) {
290 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
294 private void createContainers() {
296 final WriteTransaction t = dataBroker.newReadWriteTransaction();
298 // Create the service-instance container
299 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
300 new ServicesBuilder().build());
301 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
302 new ServicesBuilder().build());
304 // Create the PreloadInformation container
305 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadInformation.class),
306 new PreloadInformationBuilder().build());
307 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadInformation.class),
308 new PreloadInformationBuilder().build());
311 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
313 log.info("Create containers succeeded!");
315 } catch (InterruptedException | ExecutionException e) {
316 log.error("Create containers failed: ", e);
320 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
322 serviceStatusBuilder.setResponseCode(errorCode);
323 serviceStatusBuilder.setResponseMessage(errorMessage);
324 serviceStatusBuilder.setFinalIndicator(ackFinal);
325 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
328 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
329 if (requestInformation != null && requestInformation.getRequestAction() != null) {
330 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
334 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
335 if (requestHeader != null && requestHeader.getSvcAction() != null) {
336 switch (requestHeader.getSvcAction()) {
338 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
341 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
344 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
347 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
350 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
353 serviceStatusBuilder.setRpcAction(RpcAction.Create);
356 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
362 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
364 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
367 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
368 // See if any data exists yet for this siid, if so grab it.
369 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier.builder(Services.class)
370 .child(Service.class, new ServiceKey(siid)).build();
372 Optional<Service> data = Optional.absent();
373 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
374 data = readTx.read(type, serviceInstanceIdentifier).get();
375 } catch (final InterruptedException | ExecutionException e) {
376 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
379 if (data != null && data.isPresent()) {
380 ServiceData serviceData = data.get().getServiceData();
381 if (serviceData != null) {
382 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
383 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
384 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
385 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
386 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
387 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
388 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
389 serviceDataBuilder.setNetworks(serviceData.getNetworks());
390 serviceDataBuilder.setVnfs(serviceData.getVnfs());
391 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
392 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
393 serviceDataBuilder.setNetworkInstanceGroups(serviceData.getNetworkInstanceGroups());
394 serviceDataBuilder.setVnfcInstanceGroups(serviceData.getVnfcInstanceGroups());
395 serviceDataBuilder.setForwardingPaths(serviceData.getForwardingPaths());
396 serviceDataBuilder.setProvidedConfigurations(serviceData.getProvidedConfigurations());
397 // service-instance-id needs to be set
399 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
402 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
406 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
407 // Each entry will be identifiable by a unique key, we have to create that
409 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
410 .child(Service.class, entry.key()).build();
412 trySaveEntry(entry, merge, storeType, path);
415 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
416 InstanceIdentifier<T> path) {
420 save(entry, merge, storeType, path);
422 } catch (OptimisticLockFailedException e) {
424 log.debug("Got OptimisticLockFailedException on last try - failing ");
425 throw new IllegalStateException(e);
427 log.debug("Got OptimisticLockFailedException - trying again ");
428 } catch (TransactionCommitFailedException ex) {
429 log.debug("Update DataStore failed");
430 throw new IllegalStateException(ex);
435 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
436 InstanceIdentifier<T> path) throws TransactionCommitFailedException {
437 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
439 tx.merge(storeType, path, entry);
441 tx.put(storeType, path, entry);
443 tx.submit().checkedGet();
444 log.debug("Update DataStore succeeded");
447 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
448 // Each entry will be identifiable by a unique key, we have to create
450 InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
451 .child(Service.class, entry.key()).build();
453 tryDeleteEntry(storeType, path);
456 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
460 delete(storeType, path);
462 } catch (OptimisticLockFailedException e) {
464 log.debug("Got OptimisticLockFailedException on last try - failing ");
465 throw new IllegalStateException(e);
467 log.debug("Got OptimisticLockFailedException - trying again ");
468 } catch (TransactionCommitFailedException ex) {
469 log.debug("Update DataStore failed");
470 throw new IllegalStateException(ex);
475 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
476 throws TransactionCommitFailedException {
477 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
478 tx.delete(storeType, path);
479 tx.submit().checkedGet();
480 log.debug("DataStore delete succeeded");
483 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
485 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
488 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
489 LogicalDatastoreType type) {
490 // See if any data exists yet for this name/type, if so grab it.
491 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier
492 .<PreloadInformation>builder(PreloadInformation.class)
493 .child(PreloadList.class, new PreloadListKey(preloadName, preloadType)).build();
495 Optional<PreloadList> data = null;
496 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
497 data = (Optional<PreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
498 } catch (final InterruptedException | ExecutionException e) {
499 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
502 if (data != null && data.isPresent()) {
503 PreloadData preloadData = data.get().getPreloadData();
504 if (preloadData != null) {
505 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
508 .setPreloadVfModuleTopologyInformation(preloadData.getPreloadVfModuleTopologyInformation());
510 .setPreloadNetworkTopologyInformation(preloadData.getPreloadNetworkTopologyInformation());
511 preloadDataBuilder.setPreloadOperStatus(preloadData.getPreloadOperStatus());
513 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
516 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
520 private void savePreloadList(final PreloadList entry, boolean merge, LogicalDatastoreType storeType)
521 throws IllegalStateException {
523 // Each entry will be identifiable by a unique key, we have to create that
525 InstanceIdentifier.InstanceIdentifierBuilder<PreloadList> preloadListBuilder = InstanceIdentifier
526 .<PreloadInformation>builder(PreloadInformation.class).child(PreloadList.class, entry.key());
527 InstanceIdentifier<PreloadList> path = preloadListBuilder.build();
531 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
533 tx.merge(storeType, path, entry);
535 tx.put(storeType, path, entry);
537 tx.submit().checkedGet();
538 log.debug("Update DataStore succeeded");
540 } catch (final TransactionCommitFailedException e) {
541 if (e instanceof OptimisticLockFailedException) {
543 log.debug("Got OptimisticLockFailedException on last try - failing ");
544 throw new IllegalStateException(e);
546 log.debug("Got OptimisticLockFailedException - trying again ");
548 log.debug("Update DataStore failed");
549 throw new IllegalStateException(e);
555 private void deletePreloadList(final PreloadList entry, LogicalDatastoreType storeType) {
556 // Each entry will be identifiable by a unique key, we have to create
558 InstanceIdentifier<PreloadList> path = InstanceIdentifier.builder(PreloadInformation.class)
559 .child(PreloadList.class, entry.key()).build();
561 tryDeletePreloadListEntry(storeType, path);
564 private void tryDeletePreloadListEntry(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path) {
568 deletePreloadList(storeType, path);
570 } catch (OptimisticLockFailedException e) {
572 log.debug("Got OptimisticLockFailedException on last try - failing ");
573 throw new IllegalStateException(e);
575 log.debug("Got OptimisticLockFailedException - trying again ");
576 } catch (TransactionCommitFailedException ex) {
577 log.debug("Update DataStore failed");
578 throw new IllegalStateException(ex);
583 private void deletePreloadList(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path)
584 throws TransactionCommitFailedException {
585 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
586 tx.delete(storeType, path);
587 tx.submit().checkedGet();
588 log.debug("DataStore delete succeeded");
592 public ListenableFuture<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
593 ServiceTopologyOperationInput input) {
595 final String svcOperation = "service-topology-operation";
596 ServiceData serviceData;
597 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
598 Properties parms = new Properties();
600 log.info(CALLED_STR, svcOperation);
601 // create a new response object
602 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
604 if (hasInvalidServiceId(input)) {
605 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
606 responseBuilder.setResponseCode("404");
607 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
608 responseBuilder.setAckFinalIndicator("Y");
610 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
611 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
613 return Futures.immediateFuture(rpcResult);
616 // Grab the service instance ID from the input buffer
617 String siid = input.getServiceInformation().getServiceInstanceId();
619 trySetSvcRequestId(input, responseBuilder);
621 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
622 getServiceData(siid, serviceDataBuilder);
624 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
625 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
627 // Set the serviceStatus based on input
628 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
629 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
632 * // setup a service-data object builder // ACTION service-topology-operation
633 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
634 * topology-response-common; // uses service-response-information;
637 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
638 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
639 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
641 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
642 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
644 // Call SLI sync method
645 ResponseObject responseObject = new ResponseObject("200", "");
646 String ackFinal = "Y";
647 String serviceObjectPath = null;
648 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
650 if (respProps != null) {
651 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
652 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
653 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
654 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
657 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
658 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
659 serviceStatusBuilder.setRpcName(svcOperation);
661 if (failed(responseObject)) {
662 responseBuilder.setResponseCode(responseObject.getStatusCode());
663 responseBuilder.setResponseMessage(responseObject.getMessage());
664 responseBuilder.setAckFinalIndicator(ackFinal);
666 ServiceBuilder serviceBuilder = new ServiceBuilder();
667 serviceBuilder.setServiceInstanceId(siid);
668 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
670 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
671 } catch (Exception e) {
672 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
674 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
676 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
677 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
679 return Futures.immediateFuture(rpcResult);
682 // Got success from SLI
684 serviceData = serviceDataBuilder.build();
685 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
688 ServiceBuilder serviceBuilder = new ServiceBuilder();
689 serviceBuilder.setServiceData(serviceData);
690 serviceBuilder.setServiceInstanceId(siid);
691 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
692 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
694 tryDeleteService(input, serviceBuilder);
696 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
697 serviceResponseInformationBuilder.setInstanceId(siid);
698 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
699 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
701 } catch (Exception e) {
702 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
703 responseBuilder.setResponseCode("500");
704 responseBuilder.setResponseMessage(e.getMessage());
705 responseBuilder.setAckFinalIndicator("Y");
706 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
708 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
709 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
711 return Futures.immediateFuture(rpcResult);
715 responseBuilder.setResponseCode(responseObject.getStatusCode());
716 responseBuilder.setAckFinalIndicator(ackFinal);
717 trySetResponseMessage(responseBuilder, responseObject);
718 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
719 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
721 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
722 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
724 return Futures.immediateFuture(rpcResult);
727 private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder,
728 ResponseObject responseObject) {
729 if (responseObject.getMessage() != null) {
730 responseBuilder.setResponseMessage(responseObject.getMessage());
734 private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
735 return input == null || input.getServiceInformation() == null
736 || input.getServiceInformation().getServiceInstanceId() == null
737 || input.getServiceInformation().getServiceInstanceId().length() == 0;
740 private void trySetSvcRequestId(ServiceTopologyOperationInput input,
741 ServiceTopologyOperationOutputBuilder responseBuilder) {
742 if (input.getSdncRequestHeader() != null) {
743 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
747 private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
748 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
749 // Only update operational tree on delete
750 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
751 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
752 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
756 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
757 ResponseObject responseObject) {
759 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
761 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
762 } catch (Exception e) {
763 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
764 responseObject.setMessage(e.getMessage());
765 responseObject.setStatusCode("500");
768 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
769 responseObject.setStatusCode("503");
771 } catch (Exception e) {
772 responseObject.setMessage(e.getMessage());
773 responseObject.setStatusCode("500");
774 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
780 private boolean failed(ResponseObject error) {
781 return !error.getStatusCode().isEmpty()
782 && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
785 private boolean isValidRequest(ServiceTopologyOperationInput input) {
786 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
791 public ListenableFuture<RpcResult<PnfTopologyOperationOutput>> pnfTopologyOperation(
792 PnfTopologyOperationInput input) {
794 final String svcOperation = "pnf-topology-operation";
795 ServiceData serviceData;
796 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
797 Properties properties = new Properties();
799 log.info(CALLED_STR, svcOperation);
800 // create a new response object
801 PnfTopologyOperationOutputBuilder responseBuilder = new PnfTopologyOperationOutputBuilder();
803 if (hasInvalidServiceId(input)) {
804 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
805 responseBuilder.setResponseCode("404");
806 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
807 responseBuilder.setAckFinalIndicator("Y");
808 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
809 .withResult(responseBuilder.build()).build();
811 return Futures.immediateFuture(rpcResult);
814 // Grab the service instance ID from the input buffer
815 String siid = input.getServiceInformation().getServiceInstanceId();
817 trySetSvcRequestId(input, responseBuilder);
819 /* Comment out mandatory check for pnf id for scenario wherein for assign/create request pnf-id is generated by
821 if (hasInvalidPnfId(input)) {
822 log.debug("exiting {} because of null or empty pnf-id", svcOperation);
823 responseBuilder.setResponseCode("404");
824 responseBuilder.setResponseMessage("invalid input, null or empty pnf-id");
825 responseBuilder.setAckFinalIndicator("Y");
827 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
828 .withResult(responseBuilder.build()).build();
830 return Futures.immediateFuture(rpcResult);
834 String pnfId = input.getPnfDetails().getPnfId();
835 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
836 getServiceData(siid, serviceDataBuilder);
838 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
839 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
841 // Set the serviceStatus based on input
842 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
843 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
846 // setup a service-data object builder
847 // ACTION pnf-topology-operation
849 // USES sdnc-request-header;
850 // USES request-information;
851 // USES service-information;
854 // USES pnf-topology-response-body;
856 // USES service-information
860 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
861 PnfTopologyOperationInputBuilder inputBuilder = new PnfTopologyOperationInputBuilder(input);
862 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
864 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
865 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
867 // Call SLI sync method
869 ResponseObject responseObject = new ResponseObject("200", "");
870 String ackFinal = "Y";
871 String serviceObjectPath = null;
872 String pnfObjectPath = null;
873 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
875 if (respProps != null) {
876 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
877 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
878 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
880 pnfId = respProps.getProperty("pnfId");
882 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
883 pnfObjectPath = respProps.getProperty(PNF_OBJECT_PATH_PARAM);
886 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
887 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
888 serviceStatusBuilder.setRpcName(svcOperation);
890 if (failed(responseObject)) {
891 responseBuilder.setResponseCode(responseObject.getStatusCode());
892 responseBuilder.setResponseMessage(responseObject.getMessage());
893 responseBuilder.setAckFinalIndicator(ackFinal);
895 ServiceBuilder serviceBuilder = new ServiceBuilder();
896 serviceBuilder.setServiceInstanceId(siid);
897 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
899 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
900 trySaveService(input, serviceBuilder);
901 } catch (Exception e) {
902 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
904 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
906 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
907 .withResult(responseBuilder.build()).build();
910 return Futures.immediateFuture(rpcResult);
913 // Got success from SLI
915 serviceData = serviceDataBuilder.build();
916 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
919 ServiceBuilder serviceBuilder = new ServiceBuilder();
920 serviceBuilder.setServiceData(serviceData);
921 serviceBuilder.setServiceInstanceId(siid);
922 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
923 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
925 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
926 // Only update operational tree on Assign
927 log.info(UPDATING_TREE_INFO_MESSAGE);
928 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
931 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
932 serviceResponseInformationBuilder.setInstanceId(siid);
933 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
934 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
936 PnfResponseInformationBuilder pnfResponseInformationBuilder = new PnfResponseInformationBuilder();
937 pnfResponseInformationBuilder.setInstanceId(pnfId);
938 pnfResponseInformationBuilder.setObjectPath(pnfObjectPath);
939 responseBuilder.setPnfResponseInformation(pnfResponseInformationBuilder.build());
941 } catch (Exception e) {
942 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
943 responseBuilder.setResponseCode("500");
944 responseBuilder.setResponseMessage(e.getMessage());
945 responseBuilder.setAckFinalIndicator("Y");
946 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
948 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
949 .withResult(responseBuilder.build()).build();
951 return Futures.immediateFuture(rpcResult);
955 responseBuilder.setResponseCode(responseObject.getStatusCode());
956 responseBuilder.setAckFinalIndicator(ackFinal);
957 trySetResponseMessage(responseBuilder, responseObject);
958 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
959 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
961 RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
962 .withResult(responseBuilder.build()).build();
965 return Futures.immediateFuture(rpcResult);
968 private void trySetResponseMessage(PnfTopologyOperationOutputBuilder responseBuilder,
969 ResponseObject responseObject) {
970 if (responseObject.getMessage() != null) {
971 responseBuilder.setResponseMessage(responseObject.getMessage());
975 private void trySaveService(PnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
976 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
977 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
979 // Only update operational tree on activate or delete
980 log.info(UPDATING_TREE_INFO_MESSAGE);
981 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
985 private boolean hasInvalidPnfId(PnfTopologyOperationInput input) {
986 return input.getPnfDetails() == null || input.getPnfDetails().getPnfId() == null
987 || input.getPnfDetails().getPnfId().length() == 0;
990 private boolean hasInvalidServiceId(PnfTopologyOperationInput input) {
991 return input == null || input.getServiceInformation() == null
992 || input.getServiceInformation().getServiceInstanceId() == null
993 || input.getServiceInformation().getServiceInstanceId().length() == 0;
996 private void trySetSvcRequestId(PnfTopologyOperationInput input,
997 PnfTopologyOperationOutputBuilder responseBuilder) {
998 if (input.getSdncRequestHeader() != null) {
999 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1003 private boolean isValidRequest(PnfTopologyOperationInput input) {
1004 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1009 public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
1010 VnfTopologyOperationInput input) {
1012 final String svcOperation = "vnf-topology-operation";
1013 ServiceData serviceData;
1014 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1015 Properties properties = new Properties();
1017 log.info(CALLED_STR, svcOperation);
1018 // create a new response object
1019 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1021 if (hasInvalidServiceId(input)) {
1022 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1023 responseBuilder.setResponseCode("404");
1024 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1025 responseBuilder.setAckFinalIndicator("Y");
1026 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1027 .withResult(responseBuilder.build()).build();
1029 return Futures.immediateFuture(rpcResult);
1032 // Grab the service instance ID from the input buffer
1033 String siid = input.getServiceInformation().getServiceInstanceId();
1035 trySetSvcRequestId(input, responseBuilder);
1037 /* Comment out mandatory check for vnf id for scenario wherein for assign/create request vnf-id is generated by
1039 if (hasInvalidVnfId(input)) {
1040 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1041 responseBuilder.setResponseCode("404");
1042 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1043 responseBuilder.setAckFinalIndicator("Y");
1045 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1046 .withResult(responseBuilder.build()).build();
1048 return Futures.immediateFuture(rpcResult);
1052 String vnfId = input.getVnfInformation().getVnfId();
1053 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1054 getServiceData(siid, serviceDataBuilder);
1056 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1057 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1059 // Set the serviceStatus based on input
1060 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1061 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1064 // setup a service-data object builder
1065 // ACTION vnf-topology-operation
1067 // USES sdnc-request-header;
1068 // USES request-information;
1069 // USES service-information;
1070 // USES vnf-request-information
1072 // USES vnf-topology-response-body;
1073 // USES vnf-information
1074 // USES service-information
1076 // container service-data
1077 // uses vnf-configuration-information;
1078 // uses oper-status;
1080 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1081 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1082 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1084 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1085 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
1087 // Call SLI sync method
1089 ResponseObject responseObject = new ResponseObject("200", "");
1090 String ackFinal = "Y";
1091 String serviceObjectPath = null;
1092 String vnfObjectPath = null;
1093 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1095 if (respProps != null) {
1096 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1097 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1098 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1099 if (vnfId == null) {
1100 vnfId = respProps.getProperty("vnfId");
1102 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1103 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1106 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1107 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1108 serviceStatusBuilder.setRpcName(svcOperation);
1110 if (failed(responseObject)) {
1111 responseBuilder.setResponseCode(responseObject.getStatusCode());
1112 responseBuilder.setResponseMessage(responseObject.getMessage());
1113 responseBuilder.setAckFinalIndicator(ackFinal);
1115 ServiceBuilder serviceBuilder = new ServiceBuilder();
1116 serviceBuilder.setServiceInstanceId(siid);
1117 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1119 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1120 trySaveService(input, serviceBuilder);
1121 } catch (Exception e) {
1122 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1124 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1126 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1127 .withResult(responseBuilder.build()).build();
1130 return Futures.immediateFuture(rpcResult);
1133 // Got success from SLI
1135 serviceData = serviceDataBuilder.build();
1136 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1139 ServiceBuilder serviceBuilder = new ServiceBuilder();
1140 serviceBuilder.setServiceData(serviceData);
1141 serviceBuilder.setServiceInstanceId(siid);
1142 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1143 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1145 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1146 // Only update operational tree on Assign
1147 log.info(UPDATING_TREE_INFO_MESSAGE);
1148 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1151 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1152 serviceResponseInformationBuilder.setInstanceId(siid);
1153 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1154 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1156 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1157 vnfResponseInformationBuilder.setInstanceId(vnfId);
1158 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1159 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1161 } catch (Exception e) {
1162 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1163 responseBuilder.setResponseCode("500");
1164 responseBuilder.setResponseMessage(e.getMessage());
1165 responseBuilder.setAckFinalIndicator("Y");
1166 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1168 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1169 .withResult(responseBuilder.build()).build();
1171 return Futures.immediateFuture(rpcResult);
1175 responseBuilder.setResponseCode(responseObject.getStatusCode());
1176 responseBuilder.setAckFinalIndicator(ackFinal);
1177 trySetResponseMessage(responseBuilder, responseObject);
1178 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1179 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1181 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1182 .withResult(responseBuilder.build()).build();
1185 return Futures.immediateFuture(rpcResult);
1188 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
1189 ResponseObject responseObject) {
1190 if (responseObject.getMessage() != null) {
1191 responseBuilder.setResponseMessage(responseObject.getMessage());
1195 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1196 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
1197 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1199 // Only update operational tree on activate or delete
1200 log.info(UPDATING_TREE_INFO_MESSAGE);
1201 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1205 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
1206 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1207 || input.getVnfInformation().getVnfId().length() == 0;
1210 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
1211 return input == null || input.getServiceInformation() == null
1212 || input.getServiceInformation().getServiceInstanceId() == null
1213 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1216 private void trySetSvcRequestId(VnfTopologyOperationInput input,
1217 VnfTopologyOperationOutputBuilder responseBuilder) {
1218 if (input.getSdncRequestHeader() != null) {
1219 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1223 private boolean isValidRequest(VnfTopologyOperationInput input) {
1224 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1228 public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1229 VfModuleTopologyOperationInput input) {
1231 final String svcOperation = "vf-module-topology-operation";
1232 ServiceData serviceData;
1233 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1234 Properties parms = new Properties();
1236 log.info(CALLED_STR, svcOperation);
1237 // create a new response object
1238 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1240 if (hasInvalidServiceId(input)) {
1241 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1242 responseBuilder.setResponseCode("403");
1243 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1244 responseBuilder.setAckFinalIndicator("Y");
1246 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1247 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1250 return Futures.immediateFuture(rpcResult);
1253 if (hasInvalidVnfId(input)) {
1254 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1255 responseBuilder.setResponseCode("403");
1256 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1257 responseBuilder.setAckFinalIndicator("Y");
1258 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1259 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1260 return Futures.immediateFuture(rpcResult);
1263 /*if (hasInvalidVfModuleId(input)) {
1264 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1265 responseBuilder.setResponseCode("403");
1266 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1267 responseBuilder.setAckFinalIndicator("Y");
1269 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1270 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1272 return Futures.immediateFuture(rpcResult);
1275 // Grab the service instance ID from the input buffer
1276 String siid = input.getServiceInformation().getServiceInstanceId();
1277 String vnfId = input.getVnfInformation().getVnfId();
1278 String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1280 trySetSvcRequestId(input, responseBuilder);
1282 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1283 getServiceData(siid, serviceDataBuilder);
1285 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1286 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1288 // Set the serviceStatus based on input
1289 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1290 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1293 // setup a service-data object builder
1294 // ACTION vnf-topology-operation
1296 // USES sdnc-request-header;
1297 // USES request-information;
1298 // USES service-information;
1299 // USES vnf-request-information
1301 // USES vnf-topology-response-body;
1302 // USES vnf-information
1303 // USES service-information
1305 // container service-data
1306 // uses vnf-configuration-information;
1307 // uses oper-status;
1309 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1310 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1311 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1313 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1314 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1316 // Call SLI sync method
1318 ResponseObject responseObject = new ResponseObject("200", "");
1319 String ackFinal = "Y";
1320 String serviceObjectPath = null;
1321 String vnfObjectPath = null;
1322 String vfModuleObjectPath = null;
1323 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1325 if (respProps != null) {
1326 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1327 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1328 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1329 if (vfModuleId == null) {
1330 vfModuleId = respProps.getProperty(VF_MODULE_ID_PARAM);
1331 if (vfModuleId == null) {
1332 log.debug("exiting {} because vf-module-id not found in response", svcOperation);
1333 responseBuilder.setResponseCode("403");
1334 responseBuilder.setResponseMessage("failed to generate vf-module-id");
1335 responseBuilder.setAckFinalIndicator("Y");
1337 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1338 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1340 return Futures.immediateFuture(rpcResult);
1343 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1344 vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1345 vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1348 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1349 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1350 serviceStatusBuilder.setRpcName(svcOperation);
1352 if (failed(responseObject)) {
1353 responseBuilder.setResponseCode(responseObject.getStatusCode());
1354 responseBuilder.setResponseMessage(responseObject.getMessage());
1355 responseBuilder.setAckFinalIndicator(ackFinal);
1357 ServiceBuilder serviceBuilder = new ServiceBuilder();
1358 serviceBuilder.setServiceInstanceId(siid);
1359 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1361 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1362 } catch (Exception e) {
1363 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1365 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1367 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1368 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1371 return Futures.immediateFuture(rpcResult);
1374 // Got success from SLI
1376 serviceData = serviceDataBuilder.build();
1377 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1380 ServiceBuilder serviceBuilder = new ServiceBuilder();
1381 serviceBuilder.setServiceData(serviceData);
1382 serviceBuilder.setServiceInstanceId(siid);
1383 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1384 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1386 trySaveService(input, serviceBuilder);
1388 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1389 serviceResponseInformationBuilder.setInstanceId(siid);
1390 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1391 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1393 VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1394 vnfResponseInformationBuilder.setInstanceId(vnfId);
1395 vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1396 responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1398 VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1399 vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1400 vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1401 responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1403 } catch (Exception e) {
1404 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1405 responseBuilder.setResponseCode("500");
1406 responseBuilder.setResponseMessage(e.getMessage());
1407 responseBuilder.setAckFinalIndicator("Y");
1408 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1410 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1411 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1413 return Futures.immediateFuture(rpcResult);
1417 responseBuilder.setResponseCode(responseObject.getStatusCode());
1418 responseBuilder.setAckFinalIndicator(ackFinal);
1419 trySetResponseMessage(responseBuilder, responseObject);
1420 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1421 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1423 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1424 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1427 return Futures.immediateFuture(rpcResult);
1430 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1431 ResponseObject responseObject) {
1432 if (responseObject.getMessage() != null) {
1433 responseBuilder.setResponseMessage(responseObject.getMessage());
1437 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1438 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1439 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1440 // Only update operational tree on activate or delete
1442 log.info(UPDATING_TREE_INFO_MESSAGE);
1443 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1447 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1448 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1449 if (input.getSdncRequestHeader() != null) {
1450 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1454 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1455 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1456 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1459 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1460 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1461 || input.getVnfInformation().getVnfId().length() == 0;
1464 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1465 return input == null || input.getServiceInformation() == null
1466 || input.getServiceInformation().getServiceInstanceId() == null
1467 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1470 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1471 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1475 public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1476 NetworkTopologyOperationInput input) {
1478 final String svcOperation = "network-topology-operation";
1479 ServiceData serviceData;
1480 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1481 Properties parms = new Properties();
1483 log.info(CALLED_STR, svcOperation);
1484 // create a new response object
1485 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1487 if (hasInvalidServiceId(input)) {
1488 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1489 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1492 String siid = input.getServiceInformation().getServiceInstanceId();
1494 // Get the service-instance service data from MD-SAL
1495 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1496 getServiceData(siid, serviceDataBuilder);
1498 this.trySetSvcRequestId(input, responseBuilder);
1500 ServiceData sd = serviceDataBuilder.build();
1501 if (isInvalidServiceData(sd)) {
1502 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1503 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1506 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1507 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1508 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1510 // Call SLI sync method
1512 ResponseObject responseObject = new ResponseObject("200", "");
1513 String ackFinal = "Y";
1514 String networkId = ERROR_NETWORK_ID;
1515 String serviceObjectPath = null;
1516 String networkObjectPath = null;
1517 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1519 if (respProps != null) {
1520 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1521 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1522 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1523 networkId = respProps.getProperty("networkId");
1524 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1525 networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1528 if (failed(responseObject)) {
1529 responseBuilder.setResponseCode(responseObject.getStatusCode());
1530 responseBuilder.setResponseMessage(responseObject.getMessage());
1531 responseBuilder.setAckFinalIndicator(ackFinal);
1533 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1535 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1536 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1538 return Futures.immediateFuture(rpcResult);
1541 // Got success from SLI
1544 serviceData = serviceDataBuilder.build();
1545 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1548 ServiceBuilder serviceBuilder = new ServiceBuilder();
1549 serviceBuilder.setServiceData(serviceData);
1550 serviceBuilder.setServiceInstanceId(siid);
1551 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1552 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1554 trySaveService(input, serviceBuilder);
1556 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1557 networkResponseInformationBuilder.setInstanceId(networkId);
1558 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1559 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1561 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1562 serviceResponseInformationBuilder.setInstanceId(siid);
1563 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1564 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1566 } catch (IllegalStateException e) {
1567 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1568 responseBuilder.setResponseCode("500");
1569 responseBuilder.setResponseMessage(e.getMessage());
1570 responseBuilder.setAckFinalIndicator("Y");
1571 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1573 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1574 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1576 return Futures.immediateFuture(rpcResult);
1580 responseBuilder.setResponseCode(responseObject.getStatusCode());
1581 responseBuilder.setAckFinalIndicator(ackFinal);
1582 trySetResponseMessage(responseBuilder, responseObject);
1583 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1584 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1586 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1587 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1589 return Futures.immediateFuture(rpcResult);
1592 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1593 ResponseObject responseObject) {
1594 if (responseObject.getMessage() != null) {
1595 responseBuilder.setResponseMessage(responseObject.getMessage());
1599 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1600 NetworkTopologyOperationOutputBuilder responseBuilder) {
1601 if (input.getSdncRequestHeader() != null) {
1602 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1606 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1607 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1608 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1609 // Only update operational tree on Activate
1610 log.info(UPDATING_TREE_INFO_MESSAGE);
1611 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1615 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1616 return input == null || input.getServiceInformation() == null
1617 || input.getServiceInformation().getServiceInstanceId() == null
1618 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1621 private ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1622 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1624 responseBuilder.setResponseCode("404");
1625 responseBuilder.setResponseMessage(responseMessage);
1626 responseBuilder.setAckFinalIndicator("Y");
1628 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1629 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1631 return Futures.immediateFuture(rpcResult);
1634 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1635 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1639 public ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1640 ContrailRouteTopologyOperationInput input) {
1642 final String svcOperation = "contrail-route-topology-operation";
1643 ServiceData serviceData;
1644 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1645 Properties properties = new Properties();
1647 log.info(CALLED_STR, svcOperation);
1648 // create a new response object
1649 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1651 if (hasInvalidServiceId(input)) {
1652 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1653 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1656 String siid = input.getServiceInformation().getServiceInstanceId();
1658 // Get the service-instance service data from MD-SAL
1659 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1660 getServiceData(siid, serviceDataBuilder);
1662 trySetSvcRequestId(input, responseBuilder);
1664 ServiceData sd = serviceDataBuilder.build();
1665 if (isInvalidServiceData(sd)) {
1666 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1667 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1670 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1671 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1672 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1674 // Call SLI sync method
1676 ResponseObject responseObject = new ResponseObject("200", "");
1677 String ackFinal = "Y";
1678 String allottedResourceId = ERROR_NETWORK_ID;
1679 String serviceObjectPath = null;
1680 String contrailRouteObjectPath = null;
1681 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1683 if (respProps != null) {
1684 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1685 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1686 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1687 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1688 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1689 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1692 if (failed(responseObject)) {
1693 responseBuilder.setResponseCode(responseObject.getStatusCode());
1694 responseBuilder.setResponseMessage(responseObject.getMessage());
1695 responseBuilder.setAckFinalIndicator(ackFinal);
1696 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1698 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1699 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1701 return Futures.immediateFuture(rpcResult);
1704 // Got success from SLI
1706 serviceData = serviceDataBuilder.build();
1707 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1710 ServiceBuilder serviceBuilder = new ServiceBuilder();
1711 serviceBuilder.setServiceData(serviceData);
1712 serviceBuilder.setServiceInstanceId(siid);
1713 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1714 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1716 trySaveService(input, serviceBuilder);
1718 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1719 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1720 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1721 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1723 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1724 serviceResponseInformationBuilder.setInstanceId(siid);
1725 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1726 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1728 } catch (IllegalStateException e) {
1729 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1730 responseBuilder.setResponseCode("500");
1731 responseBuilder.setResponseMessage(e.getMessage());
1732 responseBuilder.setAckFinalIndicator("Y");
1733 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1735 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1736 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1738 return Futures.immediateFuture(rpcResult);
1742 responseBuilder.setResponseCode(responseObject.getStatusCode());
1743 responseBuilder.setAckFinalIndicator(ackFinal);
1744 trySetResponseMessage(responseBuilder, responseObject);
1745 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1746 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1748 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1749 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1751 return Futures.immediateFuture(rpcResult);
1754 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1755 ResponseObject responseObject) {
1756 if (responseObject.getMessage() != null) {
1757 responseBuilder.setResponseMessage(responseObject.getMessage());
1761 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1762 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1763 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1764 // Only update operational tree on activate or delete
1765 log.info(UPDATING_TREE_INFO_MESSAGE);
1766 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1770 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1771 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1772 if (input.getSdncRequestHeader() != null) {
1773 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1777 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1778 return input == null || input.getServiceInformation() == null
1779 || input.getServiceInformation().getServiceInstanceId() == null
1780 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1783 private ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
1784 ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1785 responseBuilder.setResponseCode("404");
1786 responseBuilder.setResponseMessage(responseMessage);
1787 responseBuilder.setAckFinalIndicator("Y");
1789 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1790 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1792 return Futures.immediateFuture(rpcResult);
1795 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1796 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1800 public ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1801 SecurityZoneTopologyOperationInput input) {
1803 final String svcOperation = "security-zone-topology-operation";
1804 ServiceData serviceData;
1805 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1806 Properties parms = new Properties();
1808 log.info(CALLED_STR, svcOperation);
1809 // create a new response object
1810 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1812 if (this.hasInvalidServiceId(input)) {
1813 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1814 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1817 String siid = input.getServiceInformation().getServiceInstanceId();
1819 // Get the service-instance service data from MD-SAL
1820 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1821 getServiceData(siid, serviceDataBuilder);
1822 trySetSvcRequestId(input, responseBuilder);
1824 ServiceData sd = serviceDataBuilder.build();
1825 if (isInvalidServiceData(sd)) {
1826 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1827 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1830 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1831 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1832 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1834 // Call SLI sync method
1836 Properties respProps = null;
1838 ResponseObject responseObject = new ResponseObject("200", "");
1839 String ackFinal = "Y";
1840 String allottedResourceId = ERROR_NETWORK_ID;
1841 String serviceObjectPath = null;
1842 String securityZoneObjectPath = null;
1845 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1848 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1849 } catch (Exception e) {
1850 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1851 responseObject.setMessage(e.getMessage());
1852 responseObject.setStatusCode("500");
1855 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1856 responseObject.setStatusCode("503");
1858 } catch (Exception e) {
1859 responseObject.setStatusCode("500");
1860 responseObject.setMessage(e.getMessage());
1861 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1864 if (respProps != null) {
1865 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1866 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1867 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1868 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1869 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1870 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1873 if (failed(responseObject)) {
1874 responseBuilder.setResponseCode(responseObject.getStatusCode());
1875 responseBuilder.setResponseMessage(responseObject.getMessage());
1876 responseBuilder.setAckFinalIndicator(ackFinal);
1877 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1879 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1880 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1882 return Futures.immediateFuture(rpcResult);
1885 // Got success from SLI
1888 serviceData = serviceDataBuilder.build();
1889 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1892 ServiceBuilder serviceBuilder = new ServiceBuilder();
1893 serviceBuilder.setServiceData(serviceData);
1894 serviceBuilder.setServiceInstanceId(siid);
1895 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1896 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1898 trySaveService(input, serviceBuilder);
1900 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1901 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1902 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1903 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1905 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1906 serviceResponseInformationBuilder.setInstanceId(siid);
1907 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1908 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1910 } catch (IllegalStateException e) {
1911 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1912 responseBuilder.setResponseCode("500");
1913 responseBuilder.setResponseMessage(e.getMessage());
1914 responseBuilder.setAckFinalIndicator("Y");
1915 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1917 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1918 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1920 return Futures.immediateFuture(rpcResult);
1924 responseBuilder.setResponseCode(responseObject.getStatusCode());
1925 responseBuilder.setAckFinalIndicator(ackFinal);
1926 trySetResponseMessage(responseBuilder, responseObject);
1927 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1928 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1930 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1931 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1933 return Futures.immediateFuture(rpcResult);
1936 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1937 ResponseObject responseObject) {
1938 if (responseObject.getMessage() != null) {
1939 responseBuilder.setResponseMessage(responseObject.getMessage());
1943 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1944 if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1945 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1946 // Only update operational tree on activate or delete
1947 log.info(UPDATING_TREE_INFO_MESSAGE);
1948 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1952 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1953 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1954 if (input.getSdncRequestHeader() != null) {
1955 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1959 private boolean isInvalidServiceData(ServiceData sd) {
1960 return sd == null || sd.getServiceLevelOperStatus() == null;
1963 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1964 return input == null || input.getServiceInformation() == null
1965 || input.getServiceInformation().getServiceInstanceId() == null
1966 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1969 private ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
1970 SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1972 responseBuilder.setResponseCode("404");
1973 responseBuilder.setResponseMessage(responseMessage);
1974 responseBuilder.setAckFinalIndicator("Y");
1976 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1977 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1979 return Futures.immediateFuture(rpcResult);
1982 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1983 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1987 private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
1988 return input == null || input.getServiceInformation() == null
1989 || input.getServiceInformation().getServiceInstanceId() == null
1990 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1993 private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
1994 ResponseObject error) {
1995 if (!error.getMessage().isEmpty()) {
1996 responseBuilder.setResponseMessage(error.getMessage());
2000 private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
2001 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
2002 if (input.getSdncRequestHeader() != null) {
2003 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2007 private ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
2008 buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2010 responseBuilder.setResponseCode("404");
2011 responseBuilder.setResponseMessage(responseMessage);
2012 responseBuilder.setAckFinalIndicator("Y");
2014 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2015 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2016 .withResult(responseBuilder.build())
2019 return Futures.immediateFuture(rpcResult);
2022 private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2023 if (isValidRequest(input) &&
2024 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
2025 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2026 // Only update operational tree on activate or delete
2027 log.info(UPDATING_TREE_INFO_MESSAGE);
2028 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2032 private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
2033 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2037 public ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(
2038 ConnectionAttachmentTopologyOperationInput input) {
2039 final String svcOperation = "connection-attachment-topology-operation";
2040 Properties parms = new Properties();
2041 log.info(CALLED_STR, svcOperation);
2043 // create a new response object
2044 ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
2045 if (hasInvalidServiceId(input)) {
2046 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2047 responseBuilder.setResponseCode("404");
2048 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2049 responseBuilder.setAckFinalIndicator("Y");
2051 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2052 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2053 .withResult(responseBuilder.build())
2056 return Futures.immediateFuture(rpcResult);
2059 ServiceData serviceData;
2060 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2062 String siid = input.getServiceInformation().getServiceInstanceId();
2063 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2065 // Get the service-instance service data from MD-SAL
2066 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2067 getServiceData(siid, serviceDataBuilder);
2069 trySetSvcRequestId(input, responseBuilder);
2071 ServiceData sd = serviceDataBuilder.build();
2072 if (isInvalidServiceData(sd)) {
2073 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2074 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2077 ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(
2079 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2081 // Call SLI sync method
2082 // Get SvcLogicService reference
2083 ResponseObject responseObject = new ResponseObject("200", "");
2084 String ackFinal = "Y";
2085 String allottedResourceId = ERROR_NETWORK_ID;
2086 String serviceObjectPath = null;
2087 String connectionAttachmentObjectPath = null;
2089 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2091 if (respProps != null) {
2092 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2093 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2094 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2095 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2096 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2097 connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
2100 if (failed(responseObject)) {
2101 responseBuilder.setResponseCode(responseObject.getStatusCode());
2102 responseBuilder.setResponseMessage(responseObject.getMessage());
2103 responseBuilder.setAckFinalIndicator(ackFinal);
2105 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2107 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2108 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2109 .withResult(responseBuilder.build())
2112 return Futures.immediateFuture(rpcResult);
2115 // Got success from SLI
2118 serviceData = serviceDataBuilder.build();
2119 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2122 ServiceBuilder serviceBuilder = new ServiceBuilder();
2123 serviceBuilder.setServiceData(serviceData);
2124 serviceBuilder.setServiceInstanceId(siid);
2125 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2126 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2128 trySaveService(input, serviceBuilder);
2130 ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
2131 connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
2132 connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
2134 .setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
2136 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2137 serviceResponseInformationBuilder.setInstanceId(siid);
2138 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2139 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2141 } catch (IllegalStateException e) {
2142 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2143 responseBuilder.setResponseCode("500");
2144 responseBuilder.setResponseMessage(e.getMessage());
2145 responseBuilder.setAckFinalIndicator("Y");
2146 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2148 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2149 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2150 .withResult(responseBuilder.build())
2153 return Futures.immediateFuture(rpcResult);
2157 responseBuilder.setResponseCode(responseObject.getStatusCode());
2158 responseBuilder.setAckFinalIndicator(ackFinal);
2159 trySetResponseMessage(responseBuilder, responseObject);
2160 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2161 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2163 RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2164 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2165 .withResult(responseBuilder.build())
2168 return Futures.immediateFuture(rpcResult);
2172 public ListenableFuture<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
2173 TunnelxconnTopologyOperationInput input) {
2175 final String svcOperation = "tunnelxconn-topology-operation";
2176 Properties parms = new Properties();
2177 log.info(CALLED_STR, svcOperation);
2179 // create a new response object
2180 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
2181 if (hasInvalidServiceId(input)) {
2182 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2183 responseBuilder.setResponseCode("404");
2184 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2185 responseBuilder.setAckFinalIndicator("Y");
2187 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2188 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2190 return Futures.immediateFuture(rpcResult);
2192 String siid = input.getServiceInformation().getServiceInstanceId();
2193 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2194 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
2195 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2197 // Call SLI sync method
2199 ResponseObject responseObject = new ResponseObject("200", "");
2200 String ackFinal = "Y";
2201 String allottedResourceId = ERROR_NETWORK_ID;
2202 String serviceObjectPath = null;
2203 String tunnelxconnObjectPath = null;
2204 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2206 if (respProps != null) {
2207 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2208 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2209 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2210 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2211 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2212 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
2215 if (failed(responseObject)) {
2216 responseBuilder.setResponseCode(responseObject.getStatusCode());
2217 responseBuilder.setResponseMessage(responseObject.getMessage());
2218 responseBuilder.setAckFinalIndicator(ackFinal);
2220 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2222 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2223 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2225 return Futures.immediateFuture(rpcResult);
2228 // Got success from SLI
2230 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
2231 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
2232 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
2233 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
2235 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2236 serviceResponseInformationBuilder.setInstanceId(siid);
2237 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2238 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2240 } catch (IllegalStateException e) {
2241 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2242 responseBuilder.setResponseCode("500");
2243 responseBuilder.setResponseMessage(e.getMessage());
2244 responseBuilder.setAckFinalIndicator("Y");
2245 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2247 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2248 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2250 return Futures.immediateFuture(rpcResult);
2254 responseBuilder.setResponseCode(responseObject.getStatusCode());
2255 responseBuilder.setAckFinalIndicator(ackFinal);
2256 trySetResponseMessage(responseBuilder, responseObject);
2257 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2258 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2260 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2261 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2263 return Futures.immediateFuture(rpcResult);
2266 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2267 ResponseObject responseObject) {
2268 if (responseObject.getMessage() != null) {
2269 responseBuilder.setResponseMessage(responseObject.getMessage());
2273 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2274 return input == null || input.getServiceInformation() == null
2275 || input.getServiceInformation().getServiceInstanceId() == null
2276 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2279 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2281 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2284 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2285 } catch (Exception e) {
2286 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2287 responseObject.setMessage(e.getMessage());
2288 responseObject.setStatusCode("500");
2291 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2292 responseObject.setStatusCode("503");
2294 } catch (Exception e) {
2295 responseObject.setMessage(e.getMessage());
2296 responseObject.setStatusCode("500");
2297 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2303 public ListenableFuture<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(
2304 BrgTopologyOperationInput input) {
2305 final String svcOperation = "brg-topology-operation";
2306 Properties parms = new Properties();
2308 log.info(CALLED_STR, svcOperation);
2309 // create a new response object
2310 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2312 if (this.hasInvalidServiceId(input)) {
2314 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2315 responseBuilder.setResponseCode("404");
2316 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2317 responseBuilder.setAckFinalIndicator("Y");
2319 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2320 .withResult(responseBuilder.build()).build();
2322 return Futures.immediateFuture(rpcResult);
2325 String siid = input.getServiceInformation().getServiceInstanceId();
2327 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2328 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2329 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2331 // Call SLI sync method
2333 ResponseObject responseObject = new ResponseObject("200", "");
2334 String ackFinal = "Y";
2335 String allottedResourceId = ERROR_NETWORK_ID;
2336 String serviceObjectPath = null;
2337 String brgObjectPath = null;
2338 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2340 if (respProps != null) {
2341 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2342 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2343 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2344 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2345 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2346 brgObjectPath = respProps.getProperty("brg-object-path");
2349 if (failed(responseObject)) {
2350 responseBuilder.setResponseCode(responseObject.getStatusCode());
2351 responseBuilder.setResponseMessage(responseObject.getMessage());
2352 responseBuilder.setAckFinalIndicator(ackFinal);
2354 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2355 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2356 .withResult(responseBuilder.build()).build();
2358 return Futures.immediateFuture(rpcResult);
2361 // Got success from SLI
2364 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2365 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2366 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2367 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2369 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2370 serviceResponseInformationBuilder.setInstanceId(siid);
2371 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2372 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2374 } catch (IllegalStateException e) {
2375 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2376 responseBuilder.setResponseCode("500");
2377 responseBuilder.setResponseMessage(e.getMessage());
2378 responseBuilder.setAckFinalIndicator("Y");
2379 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2381 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2382 .withResult(responseBuilder.build()).build();
2384 return Futures.immediateFuture(rpcResult);
2388 responseBuilder.setResponseCode(responseObject.getStatusCode());
2389 responseBuilder.setAckFinalIndicator(ackFinal);
2390 trySetResponseMessage(responseBuilder, responseObject);
2391 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2392 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2394 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2395 .withResult(responseBuilder.build()).build();
2397 return Futures.immediateFuture(rpcResult);
2400 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2401 ResponseObject responseObject) {
2402 if (responseObject.getMessage() != null) {
2403 responseBuilder.setResponseMessage(responseObject.getMessage());
2407 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2408 return input == null || input.getServiceInformation() == null
2409 || input.getServiceInformation().getServiceInstanceId() == null
2410 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2413 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2414 if (respProps != null) {
2415 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2416 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2417 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2423 public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2424 PreloadNetworkTopologyOperationInput input) {
2426 final String svcOperation = "preload-network-topology-operation";
2427 PreloadData preloadData;
2428 Properties properties = new Properties();
2430 log.info(CALLED_STR, svcOperation);
2431 // create a new response object
2432 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2434 if (hasInvalidPreloadNetwork(input)) {
2435 log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2436 responseBuilder.setResponseCode("403");
2437 responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2438 responseBuilder.setAckFinalIndicator("Y");
2440 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2441 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2443 return Futures.immediateFuture(rpcResult);
2446 // Grab the preload ID from the input buffer
2447 String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2449 String preloadType = "network";
2451 trySetSvcRequestId(input, responseBuilder);
2453 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2454 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2456 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2457 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2460 // setup a preload-data object builder
2461 // ACTION preload-network-topology-operation
2463 // uses sdnc-request-header;
2464 // uses request-information;
2465 // uses preload-network-topology-information;
2467 // uses preload-topology-response-body;
2469 // container preload-data
2470 // uses preload-network-topology-information;
2471 // uses preload-oper-status;
2473 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2474 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2476 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2477 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2478 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2480 // Call SLI sync method
2481 ResponseObject responseObject = new ResponseObject("200", "");
2482 String ackFinal = "Y";
2483 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2485 if (respProps != null) {
2486 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2487 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2488 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2491 if (failed(responseObject)) {
2492 responseBuilder.setResponseCode(responseObject.getStatusCode());
2493 responseBuilder.setResponseMessage(responseObject.getMessage());
2494 responseBuilder.setAckFinalIndicator(ackFinal);
2495 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2496 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2497 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2498 return Futures.immediateFuture(rpcResult);
2501 // Got success from SLI
2503 preloadData = preloadDataBuilder.build();
2504 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2506 // preload-list object
2507 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2508 preloadListBuilder.setPreloadId(preloadId);
2509 preloadListBuilder.setPreloadType(preloadType);
2510 preloadListBuilder.setPreloadData(preloadData);
2512 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2513 log.info(UPDATING_TREE_INFO_MESSAGE);
2514 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2516 tryDeletePreload(input, preloadListBuilder);
2517 } catch (Exception e) {
2518 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2519 responseBuilder.setResponseCode("500");
2520 responseBuilder.setResponseMessage(e.getMessage());
2521 responseBuilder.setAckFinalIndicator("Y");
2522 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2523 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2524 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2525 return Futures.immediateFuture(rpcResult);
2529 responseBuilder.setResponseCode(responseObject.getStatusCode());
2530 responseBuilder.setAckFinalIndicator(ackFinal);
2531 trySetResponseMessage(responseBuilder, responseObject);
2532 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2533 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2535 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2536 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2537 return Futures.immediateFuture(rpcResult);
2540 private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2541 return input == null || input.getPreloadNetworkTopologyInformation() == null
2542 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2545 private boolean hasInvalidPreloadId(String preloadId) {
2546 return preloadId == null || preloadId.length() == 0;
2549 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2550 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2551 if (input.getSdncRequestHeader() != null) {
2552 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2556 private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2557 ResponseObject responseObject) {
2559 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2561 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2562 } catch (Exception e) {
2563 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2564 responseObject.setMessage(e.getMessage());
2565 responseObject.setStatusCode("500");
2568 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2569 responseObject.setStatusCode("503");
2571 } catch (Exception e) {
2572 responseObject.setMessage(e.getMessage());
2573 responseObject.setStatusCode("500");
2574 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2580 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2581 ResponseObject responseObject) {
2582 if (responseObject.getMessage() != null) {
2583 if (!responseObject.getMessage().isEmpty()) {
2584 responseBuilder.setResponseMessage(responseObject.getMessage());
2589 private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2590 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2591 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2592 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2593 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2598 public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2599 PreloadVfModuleTopologyOperationInput input) {
2601 final String svcOperation = "preload-vf-module-topology-operation";
2602 PreloadData preloadData;
2603 Properties properties = new Properties();
2605 log.info(CALLED_STR, svcOperation);
2606 // create a new response object
2607 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2609 if (hasInvalidPreloadVfModule(input)) {
2611 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2613 responseBuilder.setResponseCode("403");
2614 responseBuilder.setResponseMessage(
2615 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2616 responseBuilder.setAckFinalIndicator("Y");
2618 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2619 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2621 return Futures.immediateFuture(rpcResult);
2624 // Grab the preload ID from the input buffer
2625 String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2626 .getVfModuleTopologyIdentifier().getVfModuleName();
2627 String preloadType = "vf-module";
2629 trySetSvcRequestId(input, responseBuilder);
2631 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2632 getPreloadData(preloadId, preloadType, preloadDataBuilder);
2634 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2635 getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2638 // setup a preload-data object builder
2639 // ACTION preload-vf-module-topology-operation
2641 // uses sdnc-request-header;
2642 // uses request-information;
2643 // uses preload-vnf-topology-information;
2645 // uses preload-topology-response-body;
2647 // container preload-data
2648 // uses preload-vf-module-topology-information;
2649 // uses preload-oper-status;
2651 log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2652 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2654 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2655 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2656 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2658 // Call SLI sync method
2659 ResponseObject responseObject = new ResponseObject("200", "");
2660 String ackFinal = "Y";
2661 Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2663 if (respProps != null) {
2664 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2665 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2666 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2669 if (failed(responseObject)) {
2670 responseBuilder.setResponseCode(responseObject.getStatusCode());
2671 responseBuilder.setResponseMessage(responseObject.getMessage());
2672 responseBuilder.setAckFinalIndicator(ackFinal);
2673 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2674 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2675 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2676 return Futures.immediateFuture(rpcResult);
2679 // Got success from SLI
2681 preloadData = preloadDataBuilder.build();
2682 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2684 // preload-list object
2685 PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2686 preloadListBuilder.setPreloadId(preloadId);
2687 preloadListBuilder.setPreloadType(preloadType);
2688 preloadListBuilder.setPreloadData(preloadData);
2690 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2691 log.info(UPDATING_TREE_INFO_MESSAGE);
2692 savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2694 tryDeletePreload(input, preloadListBuilder);
2696 } catch (Exception e) {
2697 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2698 responseBuilder.setResponseCode("500");
2699 responseBuilder.setResponseMessage(e.getMessage());
2700 responseBuilder.setAckFinalIndicator("Y");
2701 log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2702 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2703 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2704 return Futures.immediateFuture(rpcResult);
2708 responseBuilder.setResponseCode(responseObject.getStatusCode());
2709 responseBuilder.setAckFinalIndicator(ackFinal);
2710 trySetResponseMessage(responseBuilder, responseObject);
2711 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2712 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2714 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2715 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2716 return Futures.immediateFuture(rpcResult);
2719 private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
2720 return input == null || input.getPreloadVfModuleTopologyInformation() == null
2721 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
2722 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2723 .getVfModuleTopologyIdentifier() == null
2724 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
2725 .getVfModuleName() == null;
2728 private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
2729 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
2730 if (input.getSdncRequestHeader() != null) {
2731 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2735 private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
2736 ResponseObject responseObject) {
2737 if (responseObject.getMessage() != null) {
2738 if (!responseObject.getMessage().isEmpty()) {
2739 responseBuilder.setResponseMessage(responseObject.getMessage());
2744 private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2745 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2746 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2747 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2748 deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2753 public ListenableFuture<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
2754 GenericConfigurationTopologyOperationInput input) {
2756 final String svcOperation = "generic-configuration-topology-operation";
2757 ServiceData serviceData;
2758 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2759 Properties parms = new Properties();
2761 log.info(CALLED_STR, svcOperation);
2762 // create a new response object
2763 GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
2765 if (hasInvalidService(input)) {
2766 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2767 responseBuilder.setResponseCode("404");
2768 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2769 responseBuilder.setAckFinalIndicator("Y");
2771 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2772 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2775 return Futures.immediateFuture(rpcResult);
2778 // Grab the service instance ID from the input buffer
2779 String siid = input.getServiceInformation().getServiceInstanceId();
2781 trySetSvcRequestId(input, responseBuilder);
2783 if (hasInvalidConfigurationIdOrType(input)) {
2784 log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
2785 responseBuilder.setResponseCode("404");
2786 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
2787 responseBuilder.setAckFinalIndicator("Y");
2788 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2789 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2791 return Futures.immediateFuture(rpcResult);
2794 // Grab the configuration ID from the input buffer
2795 String configId = input.getConfigurationInformation().getConfigurationId();
2797 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2798 getServiceData(siid, serviceDataBuilder);
2800 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2801 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2803 // Set the serviceStatus based on input
2804 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2805 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2807 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2808 GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
2810 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2812 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2813 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2815 // Call SLI sync method
2817 ResponseObject responseObject = new ResponseObject("200", "");
2818 String ackFinal = "Y";
2819 String serviceObjectPath = "";
2820 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2822 if (respProps != null) {
2823 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2824 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2825 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2826 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2829 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2830 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2831 serviceStatusBuilder.setRpcName(svcOperation);
2833 if (failed(responseObject)) {
2834 responseBuilder.setResponseCode(responseObject.getStatusCode());
2835 responseBuilder.setResponseMessage(responseObject.getMessage());
2836 responseBuilder.setAckFinalIndicator(ackFinal);
2838 ServiceBuilder serviceBuilder = new ServiceBuilder();
2839 serviceBuilder.setServiceInstanceId(siid);
2840 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2842 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2843 } catch (Exception e) {
2844 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2846 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2848 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2849 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2852 return Futures.immediateFuture(rpcResult);
2855 // Got success from SLI
2857 serviceData = serviceDataBuilder.build();
2860 ServiceBuilder serviceBuilder = new ServiceBuilder();
2861 serviceBuilder.setServiceData(serviceData);
2862 serviceBuilder.setServiceInstanceId(siid);
2863 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2864 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2866 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2867 serviceResponseInformationBuilder.setInstanceId(siid);
2868 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2869 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2870 GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
2871 gcResponseInformationBuilder.setInstanceId(configId);
2872 responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
2874 } catch (Exception e) {
2875 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2876 responseBuilder.setResponseCode("500");
2877 responseBuilder.setResponseMessage(e.getMessage());
2878 responseBuilder.setAckFinalIndicator("Y");
2879 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2880 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2883 return Futures.immediateFuture(rpcResult);
2887 responseBuilder.setResponseCode(responseObject.getStatusCode());
2888 responseBuilder.setAckFinalIndicator(ackFinal);
2889 trySetResponseMessage(responseBuilder, responseObject);
2890 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2891 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2893 RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2894 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2896 return Futures.immediateFuture(rpcResult);
2899 private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
2900 return input == null || input.getServiceInformation() == null
2901 || input.getServiceInformation().getServiceInstanceId() == null
2902 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2905 private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
2906 GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
2907 if (input.getSdncRequestHeader() != null) {
2908 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2912 private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
2913 return input.getConfigurationInformation() == null
2914 || input.getConfigurationInformation().getConfigurationId() == null
2915 || input.getConfigurationInformation().getConfigurationType() == null;
2918 private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
2919 ResponseObject responseObject) {
2920 if (responseObject.getMessage() != null) {
2921 if (!responseObject.getMessage().isEmpty()) {
2922 responseBuilder.setResponseMessage(responseObject.getMessage());
2928 public ListenableFuture<RpcResult<GenericConfigurationNotificationOutput>> genericConfigurationNotification(
2929 GenericConfigurationNotificationInput input) {
2931 final String svcOperation = "generic-configuration-notification";
2932 ServiceData serviceData;
2933 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2934 Properties parms = new Properties();
2936 log.info(CALLED_STR, svcOperation);
2938 // Grab the service instance ID from the input buffer
2939 String siid = input.getServiceInformation().getServiceInstanceId();
2941 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2942 getServiceData(siid, serviceDataBuilder);
2944 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2945 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2947 // Set the serviceStatus based on input
2948 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2949 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2951 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2952 GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
2954 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2956 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2957 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2959 // Call SLI sync method
2961 ResponseObject responseObject = new ResponseObject("200", "");
2962 String ackFinal = "Y";
2963 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2965 if (respProps != null) {
2966 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2967 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2968 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2971 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2972 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2973 serviceStatusBuilder.setRpcName(svcOperation);
2975 if (failed(responseObject)) {
2976 ServiceBuilder serviceBuilder = new ServiceBuilder();
2977 serviceBuilder.setServiceInstanceId(siid);
2978 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2980 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2981 } catch (Exception e) {
2982 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2985 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
2988 return Futures.immediateFuture(rpcResult);
2991 // Got success from SLI
2993 serviceData = serviceDataBuilder.build();
2996 ServiceBuilder serviceBuilder = new ServiceBuilder();
2997 serviceBuilder.setServiceData(serviceData);
2998 serviceBuilder.setServiceInstanceId(siid);
2999 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3000 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3002 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3003 serviceResponseInformationBuilder.setInstanceId(siid);
3005 } catch (Exception e) {
3006 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3007 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3010 return Futures.immediateFuture(rpcResult);
3014 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3016 RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3019 return Futures.immediateFuture(rpcResult);
3023 public ListenableFuture<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
3024 GetpathsegmentTopologyOperationInput input) {
3026 final String svcOperation = "getpathsegment-topology-operation";
3027 ServiceData serviceData;
3028 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3029 Properties parms = new Properties();
3031 log.info(CALLED_STR, svcOperation);
3032 // create a new response object
3033 GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
3035 if (hasInvalidService(input)) {
3036 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3037 responseBuilder.setResponseCode("404");
3038 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3039 responseBuilder.setAckFinalIndicator("Y");
3041 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3042 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3044 return Futures.immediateFuture(rpcResult);
3047 // Grab the service instance ID from the input buffer
3048 String siid = input.getServiceInformation().getServiceInstanceId();
3050 trySetSvcRequestId(input, responseBuilder);
3052 if (hasInvalidOnapModelInformation(input)) {
3053 log.debug("exiting {} because no model-uuid provided", svcOperation);
3054 responseBuilder.setResponseCode("404");
3055 responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
3056 responseBuilder.setAckFinalIndicator("Y");
3057 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3058 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3059 return Futures.immediateFuture(rpcResult);
3062 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3063 getServiceData(siid, serviceDataBuilder);
3065 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3066 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3068 // Set the serviceStatus based on input
3069 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3070 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3072 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3073 GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
3075 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3077 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3078 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3080 // Call SLI sync method
3082 ResponseObject responseObject = new ResponseObject("200", "");
3083 String ackFinal = "Y";
3084 String serviceObjectPath = null;
3085 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3087 if (respProps != null) {
3088 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3089 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3090 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3091 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3094 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3095 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3096 serviceStatusBuilder.setRpcName(svcOperation);
3098 if (failed(responseObject)) {
3099 responseBuilder.setResponseCode(responseObject.getStatusCode());
3100 responseBuilder.setResponseMessage(responseObject.getMessage());
3101 responseBuilder.setAckFinalIndicator(ackFinal);
3103 ServiceBuilder serviceBuilder = new ServiceBuilder();
3104 serviceBuilder.setServiceInstanceId(siid);
3105 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3107 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3108 } catch (Exception e) {
3109 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3111 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3113 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3114 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3116 return Futures.immediateFuture(rpcResult);
3119 // Got success from SLI
3121 serviceData = serviceDataBuilder.build();
3122 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3125 ServiceBuilder serviceBuilder = new ServiceBuilder();
3126 serviceBuilder.setServiceData(serviceData);
3127 serviceBuilder.setServiceInstanceId(siid);
3128 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3129 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3131 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3132 serviceResponseInformationBuilder.setInstanceId(siid);
3133 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3134 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3136 } catch (Exception e) {
3137 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3138 responseBuilder.setResponseCode("500");
3139 responseBuilder.setResponseMessage(e.getMessage());
3140 responseBuilder.setAckFinalIndicator("Y");
3141 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3142 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3144 return Futures.immediateFuture(rpcResult);
3148 responseBuilder.setResponseCode(responseObject.getStatusCode());
3149 responseBuilder.setAckFinalIndicator(ackFinal);
3150 trySetResponseMessage(responseBuilder, responseObject);
3151 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3152 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3154 RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3155 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3157 return Futures.immediateFuture(rpcResult);
3160 private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
3161 return input == null || input.getServiceInformation() == null
3162 || input.getServiceInformation().getServiceInstanceId() == null
3163 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3166 private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
3167 GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
3168 if (input.getSdncRequestHeader() != null) {
3169 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3173 private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
3174 return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
3175 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
3178 private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
3179 ResponseObject responseObject) {
3180 if (responseObject.getMessage() != null) {
3181 if (!responseObject.getMessage().isEmpty()) {
3182 responseBuilder.setResponseMessage(responseObject.getMessage());
3188 public ListenableFuture<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
3189 PolicyUpdateNotifyOperationInput input) {
3191 final String svcOperation = "policy-update-notify-operation";
3192 Properties parms = new Properties();
3194 log.info(CALLED_STR, svcOperation);
3196 // create a new response object
3197 PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
3199 // Make sure we have a valid input
3200 if (hasInvalidInput(input)) {
3201 log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
3202 responseBuilder.setErrorCode("404");
3203 responseBuilder.setErrorMsg("Invalid input, missing input data");
3204 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3205 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3206 return Futures.immediateFuture(rpcResult);
3209 log.info("Adding INPUT data for {} input: {}", svcOperation, input);
3210 PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
3211 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3213 // Call SLI sync method
3214 ResponseObject responseObject = new ResponseObject("200", "");
3215 String ackFinal = "Y";
3216 String serviceObjectPath = null;
3217 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
3219 if (respProps != null) {
3220 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3221 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3222 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3223 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3226 if (failed(responseObject)) {
3227 responseBuilder.setErrorCode(responseObject.getStatusCode());
3228 responseBuilder.setErrorMsg(responseObject.getMessage());
3229 log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
3231 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3232 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3234 return Futures.immediateFuture(rpcResult);
3237 // Got success from SLI
3238 responseBuilder.setErrorCode(responseObject.getStatusCode());
3239 if (responseObject.getMessage() != null) {
3240 responseBuilder.setErrorMsg(responseObject.getMessage());
3242 log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
3243 RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3244 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3246 return Futures.immediateFuture(rpcResult);
3249 private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
3250 return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3254 public ListenableFuture<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3255 final PortMirrorTopologyOperationInput input) {
3257 final String svcOperation = "port-mirror-topology-operation";
3258 ServiceData serviceData = null;
3259 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3260 Properties properties = new Properties();
3262 log.info(CALLED_STR, svcOperation);
3264 // create a new response object
3265 PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3267 if (hasInvalidService(input)) {
3268 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3269 responseBuilder.setResponseCode("404");
3270 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3271 responseBuilder.setAckFinalIndicator("Y");
3272 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3273 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3275 return Futures.immediateFuture(rpcResult);
3278 if (hasInvalidConfigurationId(input)) {
3279 log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3280 responseBuilder.setResponseCode("404");
3281 responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3282 responseBuilder.setAckFinalIndicator("Y");
3283 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3284 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3285 return Futures.immediateFuture(rpcResult);
3288 // Grab the service instance ID from the input buffer
3289 String siid = input.getServiceInformation().getServiceInstanceId();
3291 trySetSvcRequestId(input, responseBuilder);
3293 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3294 getServiceData(siid, serviceDataBuilder);
3296 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3297 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3299 // Set the serviceStatus based on input
3300 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3301 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3303 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3304 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3305 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3307 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3308 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3310 // Call SLI sync method
3311 ResponseObject responseObject = new ResponseObject("200", "");
3312 String ackFinal = "Y";
3313 String serviceObjectPath = null;
3314 String portMirrorObjectPath = null;
3315 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3317 if (respProps != null) {
3318 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3319 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3320 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3321 serviceObjectPath = respProps.getProperty("service-object-path");
3322 portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3325 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3326 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3327 serviceStatusBuilder.setRpcName(svcOperation);
3329 if (failed(responseObject)) {
3330 responseBuilder.setResponseCode(responseObject.getStatusCode());
3331 responseBuilder.setResponseMessage(responseObject.getMessage());
3332 responseBuilder.setAckFinalIndicator(ackFinal);
3334 ServiceBuilder serviceBuilder = new ServiceBuilder();
3335 serviceBuilder.setServiceInstanceId(siid);
3336 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3338 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3339 } catch (Exception e) {
3340 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3342 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3344 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3345 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3348 return Futures.immediateFuture(rpcResult);
3351 // Got success from SLI
3353 serviceData = serviceDataBuilder.build();
3354 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3357 ServiceBuilder serviceBuilder = new ServiceBuilder();
3358 serviceBuilder.setServiceData(serviceData);
3359 serviceBuilder.setServiceInstanceId(siid);
3360 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3361 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3363 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3364 // Only update operational tree on activate or delete
3365 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3366 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3367 log.info(UPDATING_TREE_INFO_MESSAGE);
3368 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3372 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3373 serviceResponseInformationBuilder.setInstanceId(siid);
3374 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3375 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3376 PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3377 portMirrorResponseInformationBuilder
3378 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3379 portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3380 responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3382 } catch (Exception e) {
3383 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3384 responseBuilder.setResponseCode("500");
3385 responseBuilder.setResponseMessage(e.getMessage());
3386 responseBuilder.setAckFinalIndicator("Y");
3387 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3388 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3389 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3390 return Futures.immediateFuture(rpcResult);
3394 responseBuilder.setResponseCode(responseObject.getStatusCode());
3395 responseBuilder.setAckFinalIndicator(ackFinal);
3396 trySetResponseMessage(responseBuilder, responseObject);
3397 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3398 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3400 RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3401 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3403 if (ackFinal.equals("N")) {
3404 // Spawn background thread to invoke the Async DG
3405 Runnable backgroundThread = new Runnable() {
3407 log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3408 processAsyncPortMirrorTopologyOperation(input);
3411 new Thread(backgroundThread).start();
3415 return Futures.immediateFuture(rpcResult);
3418 private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3419 return input == null || input.getServiceInformation() == null
3420 || input.getServiceInformation().getServiceInstanceId() == null
3421 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3424 private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3425 return input.getConfigurationInformation() == null
3426 || input.getConfigurationInformation().getConfigurationId() == null
3427 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3430 private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3431 PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3432 if (input.getSdncRequestHeader() != null) {
3433 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3437 private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3438 ResponseObject responseObject) {
3439 if (responseObject.getMessage() != null) {
3440 if (!responseObject.getMessage().isEmpty()) {
3441 responseBuilder.setResponseMessage(responseObject.getMessage());
3446 public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3447 log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3449 final String svcOperation = "port-mirror-topology-operation-async";
3450 ServiceData serviceData = null;
3451 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3452 Properties parms = new Properties();
3454 log.info(CALLED_STR, svcOperation);
3456 // Grab the service instance ID from the input buffer
3457 String siid = input.getServiceInformation().getServiceInstanceId();
3459 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3460 getServiceData(siid, serviceDataBuilder);
3462 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3463 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3465 // Set the serviceStatus based on input
3466 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3467 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3469 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3470 PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3471 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3473 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3474 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3476 // Call SLI sync method
3477 ResponseObject responseObject = new ResponseObject("200", "");
3478 String ackFinal = "Y";
3479 String serviceObjectPath = null;
3480 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3482 if (respProps != null) {
3483 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3484 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3485 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3488 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3489 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3490 serviceStatusBuilder.setRpcName(svcOperation);
3492 if (failed(responseObject)) {
3493 ServiceBuilder serviceBuilder = new ServiceBuilder();
3494 serviceBuilder.setServiceInstanceId(siid);
3495 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3497 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3498 } catch (Exception e) {
3499 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3506 // Got success from SLI
3508 serviceData = serviceDataBuilder.build();
3509 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3512 ServiceBuilder serviceBuilder = new ServiceBuilder();
3513 serviceBuilder.setServiceData(serviceData);
3514 serviceBuilder.setServiceInstanceId(siid);
3515 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3516 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3518 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3519 // Only update operational tree on activate or delete
3520 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3521 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3522 log.info(UPDATING_TREE_INFO_MESSAGE);
3523 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3527 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3528 serviceResponseInformationBuilder.setInstanceId(siid);
3529 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3531 } catch (Exception e) {
3532 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3537 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3543 public ListenableFuture<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(
3544 VnfGetResourceRequestInput input) {
3546 final String svcOperation = "vnf-get-resource-request";
3547 ServiceData serviceData;
3548 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3549 Properties parms = new Properties();
3551 log.info(CALLED_STR, svcOperation);
3552 // create a new response object
3553 VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3555 if (hasInvalidService(input)) {
3556 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3557 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3558 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3560 return Futures.immediateFuture(rpcResult);
3563 // Grab the service instance ID from the input buffer
3564 String siid = input.getServiceInformation().getServiceInstanceId();
3566 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3567 getServiceData(siid, serviceDataBuilder);
3569 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3570 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3572 // Set the serviceStatus based on input
3573 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3574 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3576 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3577 VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3578 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3580 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3581 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3583 // Call SLI sync method
3585 ResponseObject responseObject = new ResponseObject("200", "");
3586 String ackFinal = "Y";
3587 String serviceObjectPath = null;
3588 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3590 if (respProps != null) {
3591 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3592 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3593 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3594 serviceObjectPath = respProps.getProperty("service-object-path");
3597 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3598 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3599 serviceStatusBuilder.setRpcName(svcOperation);
3601 if (failed(responseObject)) {
3602 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3603 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3604 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3606 return Futures.immediateFuture(rpcResult);
3609 // Got success from SLI
3610 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3612 if (respProps != null) {
3613 GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3616 RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3617 .withResult(responseBuilder.build()).build();
3620 return Futures.immediateFuture(rpcResult);
3623 private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3624 return input == null || input.getServiceInformation() == null
3625 || input.getServiceInformation().getServiceInstanceId() == null
3626 || input.getServiceInformation().getServiceInstanceId().length() == 0;