2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 * ============LICENSE_END=========================================================
22 package org.onap.sdnc.vnfapi;
24 import com.google.common.util.concurrent.CheckedFuture;
25 import com.google.common.util.concurrent.FutureCallback;
26 import com.google.common.util.concurrent.Futures;
27 import com.google.common.util.concurrent.ListenableFuture;
28 import com.google.common.base.Optional;
29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
30 import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
31 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
32 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
33 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
34 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
35 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
36 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
37 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
38 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
39 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInput;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutput;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutputBuilder;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInput;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInputBuilder;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutput;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutputBuilder;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInput;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInputBuilder;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutput;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutputBuilder;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModules;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModulesBuilder;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInput;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInputBuilder;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutput;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutputBuilder;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstances;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstancesBuilder;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInput;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInputBuilder;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutput;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutputBuilder;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfs;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfsBuilder;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VNFAPIService;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutput;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutputBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModules;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModulesBuilder;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInputBuilder;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstances;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstancesBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInput;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInputBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutput;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutputBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.Vnfs;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfsBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.information.NetworkInformationBuilder;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadData;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadDataBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadList;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListBuilder;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListKey;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadList;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListBuilder;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListKey;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadList;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListBuilder;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListKey;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader.SvcAction;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceData;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceDataBuilder;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RequestStatus;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcAction;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcName;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnAction;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnSubaction;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatusBuilder;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.information.VfModuleInformationBuilder;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleList;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListBuilder;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListKey;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadData;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadDataBuilder;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceData;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceDataBuilder;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.information.VnfInformationBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.information.VnfInstanceInformationBuilder;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceList;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListBuilder;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListKey;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadData;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadDataBuilder;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceData;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
126 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfList;
127 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListBuilder;
128 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListKey;
129 import org.opendaylight.yangtools.yang.binding.DataObject;
130 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
131 import org.opendaylight.yangtools.yang.common.RpcResult;
132 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
133 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
134 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
135 import org.slf4j.Logger;
136 import org.slf4j.LoggerFactory;
137 import org.slf4j.MDC;
140 import java.text.DateFormat;
141 import java.text.SimpleDateFormat;
142 import java.util.Date;
143 import java.util.Properties;
144 import java.util.TimeZone;
145 import java.util.concurrent.ExecutionException;
146 import java.util.concurrent.ExecutorService;
147 import java.util.concurrent.Executors;
148 import java.util.ArrayList;
149 import java.util.Collection;
150 import java.util.concurrent.Future;
153 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
154 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
155 * initialization / clean up methods.
158 public class VnfApiProvider implements AutoCloseable, VNFAPIService {
160 protected DataBroker dataBroker;
161 protected NotificationPublishService notificationService;
162 protected RpcProviderRegistry rpcRegistry;
163 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
164 private final Logger log = LoggerFactory.getLogger(VnfApiProvider.class);
165 private final ExecutorService executor;
167 private static final String PRELOAD_DATA = "] PreloadData: ";
168 private static final String SENDING_SUCCESS_RPC = "Sending Success rpc result due to external error";
169 public static final String REASON = "', Reason: '";
170 public static final String ERROR_CODE = "] error code: '";
171 public static final String INVALID_INPUT_INVALID_PRELOAD_TYPE = "invalid input, invalid preload-type";
172 public static final String BECAUSE_OF_INVALID_PRELOAD_TYPE = " because of invalid preload-type";
173 public static final String INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = "invalid input, null or empty service-instance-id";
174 public static final String BECAUSE_OF_INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = " because of invalid input, null or empty service-instance-id";
175 private static final String APP_NAME = "vnfapi";
176 private static final String VNF_API = "VNF-API";
177 private static final String OPERATIONAL_DATA = "operational-data";
178 private static final String READ_MD_SAL_STR = "Read MD-SAL (";
179 private static final String DATA_FOR_STR = ") data for [";
180 private static final String SERVICE_DATA_STR = "] ServiceData: ";
181 private static final String NO_DATA_FOUND_STR = "No data found in MD-SAL (";
182 private static final String EXCEPTION_READING_MD_SAL_STR = "Caught Exception reading MD-SAL (";
183 private static final String FOR_STR = ") for [";
184 private static final String INVALID_INPUT_VF_MODULE_STR = "invalid input, null or empty vf-module-id";
185 private static final String UPDATED_MD_SAL_STR = "Updated MD-SAL for ";
186 private static final String RETURNED_SUCCESS_STR = "Returned SUCCESS for ";
187 private static final String UPDATING_OPERATIONAL_TREE_STR = "Updating OPERATIONAL tree.";
188 private static final String UPDATING_MD_SAL_STR = "Updating MD-SAL for ";
189 private static final String CAUGHT_EXCEPTION_STR = "Caught Exception updating MD-SAL for ";
190 private static final String RETURNED_FAILED_STR = "Returned FAILED for ";
191 private static final String ADDING_INPUT_DATA_STR = "Adding INPUT data for ";
192 private static final String ADDING_OPERATIONAL_DATA_STR = "Adding OPERATIONAL data for ";
193 private static final String OPERATIONAL_DATA_STR = "] operational-data: ";
194 private static final String ADDING_CONFIG_DATA_STR = "Adding CONFIG data for ";
195 private static final String INPUT_STR = "] input: ";
196 private static final String CALLED_STR = " called.";
197 private static final String EXITING_STR = "exiting ";
198 private static final String INVALID_INPUT_VNF_INSTANCE_STR = "invalid input, null or empty vnf-instance-id";
200 private VNFSDNSvcLogicServiceClient svcLogicClient;
202 public VnfApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
203 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
204 log.info("Creating provider for " + APP_NAME);
205 executor = Executors.newFixedThreadPool(1);
206 dataBroker = dataBroker2;
207 notificationService = notificationPublishService;
208 rpcRegistry = rpcProviderRegistry;
209 svcLogicClient = client;
213 private void initialize() {
214 log.info("Initializing provider for " + APP_NAME);
215 // Create the top level containers
218 VnfSdnUtil.loadProperties();
219 } catch (Exception e) {
220 log.error("Caught Exception while trying to load properties file: ", e);
223 log.info("Initialization complete for " + APP_NAME);
226 private void createContainers() {
227 final WriteTransaction t = dataBroker.newReadWriteTransaction();
229 // Create the Vnfs container
230 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
231 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
233 // Create the PreloadVnfs container
234 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
235 new PreloadVnfsBuilder().build());
236 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
237 new PreloadVnfsBuilder().build());
239 // 1610 Create the PreloadVnfInstances container
240 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
241 new PreloadVnfInstancesBuilder().build());
242 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
243 new PreloadVnfInstancesBuilder().build());
245 // 1610 Create the VnfInstances container
246 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
247 new VnfInstancesBuilder().build());
248 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
249 new VnfInstancesBuilder().build());
251 // 1610 Create the PreloadVfModules container
252 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
253 new PreloadVfModulesBuilder().build());
254 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
255 new PreloadVfModulesBuilder().build());
257 // 1610 Create the VfModules container
258 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
259 new VfModulesBuilder().build());
260 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
261 new VfModulesBuilder().build());
264 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
266 log.info("Create Containers succeeded!: ");
268 } catch (InterruptedException | ExecutionException e) {
269 log.error("Create Containers Failed: " + e);
274 public void close() throws Exception {
275 log.info("Closing provider for " + APP_NAME);
277 rpcRegistration.close();
278 log.info("Successfully closed provider for " + APP_NAME);
282 private static class Iso8601Util {
285 private static TimeZone tz = TimeZone.getTimeZone("UTC");
286 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
288 private Iso8601Util() {
295 private static String now() {
296 return df.format(new Date());
300 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
302 serviceStatusBuilder.setResponseCode(errorCode);
303 serviceStatusBuilder.setResponseMessage(errorMessage);
304 serviceStatusBuilder.setFinalIndicator(ackFinal);
305 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
308 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
309 if (requestInformation != null && requestInformation.getRequestAction() != null) {
310 switch (requestInformation.getRequestAction()) {
311 case VNFActivateRequest:
312 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
314 case ChangeVNFActivateRequest:
315 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
317 case DisconnectVNFRequest:
318 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
320 case PreloadVNFRequest:
321 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
323 case DeletePreloadVNFRequest:
324 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
326 // 1610 vnf-instance Requests
327 case VnfInstanceActivateRequest:
328 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
330 case ChangeVnfInstanceActivateRequest:
331 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
333 case DisconnectVnfInstanceRequest:
334 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
336 case PreloadVnfInstanceRequest:
337 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
339 // 1610 vf-module Requests
340 case VfModuleActivateRequest:
341 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
343 case ChangeVfModuleActivateRequest:
344 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
346 case DisconnectVfModuleRequest:
347 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
349 case PreloadVfModuleRequest:
350 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
353 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
357 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
358 switch (requestInformation.getRequestSubAction()) {
360 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
363 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
366 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
372 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
373 if (requestHeader != null && requestHeader.getSvcAction() != null) {
374 switch (requestHeader.getSvcAction()) {
376 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
379 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
382 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
385 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
388 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
391 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
394 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
397 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
403 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
405 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
409 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
410 // See if any data exists yet for this siid, if so grab it.
411 InstanceIdentifier<VnfList> serviceInstanceIdentifier = InstanceIdentifier
413 .child(VnfList.class, new VnfListKey(siid))
416 Optional<VnfList> data = Optional.absent();
417 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
418 data = readTx.read(type, serviceInstanceIdentifier).get();
419 } catch (final InterruptedException | ExecutionException e) {
420 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
423 if (data.isPresent()) {
424 ServiceData serviceData = (ServiceData) data.get().getServiceData();
425 if (serviceData != null) {
426 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + SERVICE_DATA_STR + serviceData);
427 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
428 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
429 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
430 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
431 serviceDataBuilder.setVnfId(serviceData.getVnfId());
432 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
433 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
435 log.info("No service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
438 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
443 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
445 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
449 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
450 LogicalDatastoreType type) {
451 // See if any data exists yet for this siid, if so grab it.
452 InstanceIdentifier<VnfInstanceList> vnfInstanceIdentifier = InstanceIdentifier
453 .builder(VnfInstances.class)
454 .child(VnfInstanceList.class, new VnfInstanceListKey(siid))
457 Optional<VnfInstanceList> data = Optional.absent();
458 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
459 data = readTx.read(type, vnfInstanceIdentifier).get();
460 } catch (final InterruptedException | ExecutionException e) {
461 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
464 if (data.isPresent()) {
465 VnfInstanceServiceData vnfInstanceServiceData = data.get().getVnfInstanceServiceData();
466 if (vnfInstanceServiceData != null) {
467 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VnfInstanceServiceData: "
468 + vnfInstanceServiceData);
469 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
470 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
471 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
472 vnfInstanceServiceDataBuilder
473 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
474 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
475 vnfInstanceServiceDataBuilder
476 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
477 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
479 log.info("No vnf-instance-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
482 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
487 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
489 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
493 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
494 LogicalDatastoreType type) {
495 // See if any data exists yet for this siid, if so grab it.
496 InstanceIdentifier<VfModuleList> vfModuleIdentifier = InstanceIdentifier
497 .builder(VfModules.class)
498 .child(VfModuleList.class, new VfModuleListKey(siid))
501 Optional<VfModuleList> data = Optional.absent();
502 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
503 data = readTx.read(type, vfModuleIdentifier).get();
504 } catch (final InterruptedException | ExecutionException e) {
505 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
508 if (data.isPresent()) {
509 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
510 if (vfModuleServiceData != null) {
512 READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VfModuleServiceData: " + vfModuleServiceData);
513 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
514 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
515 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
516 vfModuleServiceDataBuilder
517 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
518 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
519 vfModuleServiceDataBuilder
520 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
521 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
523 log.info("No vf-module-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
526 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
531 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
533 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
536 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
537 LogicalDatastoreType type) {
538 // See if any data exists yet for this name/type, if so grab it.
539 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
540 .builder(PreloadVnfs.class)
541 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
544 Optional<VnfPreloadList> data = Optional.absent();
545 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
546 data = readTx.read(type, preloadInstanceIdentifier).get();
547 } catch (final InterruptedException | ExecutionException e) {
548 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ", e);
551 if (data.isPresent()) {
552 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
553 if (preloadData != null) {
554 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType + PRELOAD_DATA
556 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
557 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
558 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
561 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
564 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
568 //1610 preload-vnf-instance
569 private void getVnfInstancePreloadData(String vnfName, String vnfType,
570 VnfInstancePreloadDataBuilder preloadDataBuilder) {
572 getVnfInstancePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
575 //1610 preload-vnf-instance
576 private void getVnfInstancePreloadData(String preloadName, String preloadType,
577 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
578 // See if any data exists yet for this name/type, if so grab it.
579 InstanceIdentifier<VnfInstancePreloadList> preloadInstanceIdentifier = InstanceIdentifier
580 .builder(PreloadVnfInstances.class)
581 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preloadName, preloadType))
584 Optional<VnfInstancePreloadList> data = Optional.absent();
585 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
586 data = readTx.read(type, preloadInstanceIdentifier).get();
587 } catch (final InterruptedException | ExecutionException e) {
588 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ", e);
591 if (data.isPresent()) {
592 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
593 if (preloadData != null) {
594 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
595 + "] VnfInstancePreloadData: " + preloadData);
596 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
597 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
599 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + FOR_STR + preloadName + ","
600 + preloadType + "] ");
603 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
607 // 1610 preload-vf-module
608 private void getVfModulePreloadData(String vnfName, String vnfType,
609 VfModulePreloadDataBuilder preloadDataBuilder) {
611 getVfModulePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
614 private void getVfModulePreloadData(String preloadName, String preloadType,
615 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
616 // See if any data exists yet for this name/type, if so grab it.
617 InstanceIdentifier<VfModulePreloadList> preloadInstanceIdentifier = InstanceIdentifier
618 .builder(PreloadVfModules.class)
619 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preloadName, preloadType))
622 Optional<VfModulePreloadList> data = Optional.absent();
623 try (final ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction()) {
624 data = readTx.read(type, preloadInstanceIdentifier).get();
625 } catch (final InterruptedException | ExecutionException e) {
626 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ", e);
629 if (data.isPresent()) {
630 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
631 if (preloadData != null) {
632 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
633 + "] VfModulePreloadData: " + preloadData);
634 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
635 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
638 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
641 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
645 private void deleteVnfList(final VnfList entry, LogicalDatastoreType storeType) {
646 // Each entry will be identifiable by a unique key, we have to create that identifier
647 InstanceIdentifier<VnfList> path = InstanceIdentifier
649 .child(VnfList.class, entry.key())
652 int optimisticLockTries = 2;
653 boolean tryAgain = true;
657 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
658 tx.delete(storeType, path);
659 tx.submit().checkedGet();
660 log.debug("DataStore delete succeeded");
661 } catch (OptimisticLockFailedException e) {
662 if (--optimisticLockTries <= 0) {
663 log.debug("Got OptimisticLockFailedException on last try - failing ");
664 throw new IllegalStateException(e);
666 log.debug("Got OptimisticLockFailedException - trying again ");
669 } catch (final TransactionCommitFailedException e) {
670 Throwable eCause = e.getCause();
672 if (eCause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
673 log.debug("Nested TransactionCommitFailed exception - getting next cause");
674 eCause = eCause.getCause();
676 log.debug("Got TransactionCommitFailedException, caused by {}", eCause.getClass().getName());
679 if (eCause instanceof ModifiedNodeDoesNotExistException) {
680 log.debug("Ignoring ModifiedNodeDoesNotExistException");
684 log.debug("Delete DataStore failed due to exception", eCause);
685 throw new IllegalStateException(e);
690 private void saveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType) {
691 // Each entry will be identifiable by a unique key, we have to create that identifier
692 InstanceIdentifier<VnfList> path = InstanceIdentifier
694 .child(VnfList.class, entry.key())
697 tryUpdateDataStore(entry, merge, storeType, path);
701 private void saveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) {
702 // Each entry will be identifiable by a unique key, we have to create that identifier
703 InstanceIdentifier<VnfInstanceList> path = InstanceIdentifier
704 .builder(VnfInstances.class)
705 .child(VnfInstanceList.class, entry.key())
708 tryUpdateDataStore(entry, merge, storeType, path);
712 private void saveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) {
713 // Each entry will be identifiable by a unique key, we have to create that identifier
714 InstanceIdentifier<VfModuleList> path = InstanceIdentifier
715 .builder(VfModules.class)
716 .child(VfModuleList.class, entry.key())
719 tryUpdateDataStore(entry, merge, storeType, path);
722 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
724 // Each entry will be identifiable by a unique key, we have to create that identifier
725 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
726 .builder(PreloadVnfs.class)
727 .child(VnfPreloadList.class, entry.key())
730 tryUpdateDataStore(entry, merge, storeType, path);
733 //1610 preload vnf-instance
734 private void saveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
735 LogicalDatastoreType storeType) {
737 // Each entry will be identifiable by a unique key, we have to create that identifier
738 InstanceIdentifier<VnfInstancePreloadList> path = InstanceIdentifier
739 .builder(PreloadVnfInstances.class)
740 .child(VnfInstancePreloadList.class, entry.key())
743 tryUpdateDataStore(entry, merge, storeType, path);
746 //1610 preload vf-module
747 private void saveVfModulePreloadList(final VfModulePreloadList entry, boolean merge,
748 LogicalDatastoreType storeType) {
750 // Each entry will be identifiable by a unique key, we have to create that identifier
751 InstanceIdentifier<VfModulePreloadList> path = InstanceIdentifier
752 .builder(PreloadVfModules.class)
753 .child(VfModulePreloadList.class, entry.key())
756 tryUpdateDataStore(entry, merge, storeType, path);
759 private <T extends DataObject> void tryUpdateDataStore(T entry, boolean merge, LogicalDatastoreType storeType,
760 InstanceIdentifier<T> path) {
765 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
767 tx.merge(storeType, path, entry);
769 tx.put(storeType, path, entry);
771 tx.submit().checkedGet();
772 log.debug("Update DataStore succeeded");
774 } catch (OptimisticLockFailedException e) {
776 log.debug("Got OptimisticLockFailedException on last try - failing ");
777 throw new IllegalStateException(e);
779 log.debug("Got OptimisticLockFailedException - trying again ");
780 } catch (final TransactionCommitFailedException e) {
781 log.debug("Update DataStore failed");
782 throw new IllegalStateException(e);
787 //Save the requestId into MDC
788 private void setRequestIdAsMDC(String requestId) {
789 MDC.put("RequestId", requestId);
792 //1610 vnf-instance-topology-operation
794 private Boolean validateVnfInstanceTopologyOperationInput(VnfInstanceTopologyOperationInput input) {
796 && input.getVnfInstanceRequestInformation() != null
797 && input.getVnfInstanceRequestInformation().getVnfInstanceId() != null
798 && input.getVnfInstanceRequestInformation().getVnfInstanceId().length() != 0;
801 private ListenableFuture<RpcResult<VnfInstanceTopologyOperationOutput>> buildVnfInstanceTopologyOperationOutputWithtError(
802 String responseCode, String responseMessage, String ackFinalIndicator) {
803 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
804 responseBuilder.setResponseCode(responseCode);
805 responseBuilder.setResponseMessage(responseMessage);
806 responseBuilder.setAckFinalIndicator(ackFinalIndicator);
807 return Futures.immediateFuture(RpcResultBuilder
808 .<VnfInstanceTopologyOperationOutput>status(true)
809 .withResult(responseBuilder.build())
814 public ListenableFuture<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
815 VnfInstanceTopologyOperationInput input) {
817 final String svcOperation = "vnf-instance-topology-operation";
818 VnfInstanceServiceData vnfInstanceServiceData;
819 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
820 Properties parms = new Properties();
822 log.info(svcOperation + CALLED_STR);
823 // create a new response object
824 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
826 if (!validateVnfInstanceTopologyOperationInput(input)) {
827 log.debug(EXITING_STR + svcOperation + " because of " + INVALID_INPUT_VNF_INSTANCE_STR);
828 return buildVnfInstanceTopologyOperationOutputWithtError("403",
829 INVALID_INPUT_VNF_INSTANCE_STR,
833 // Grab the service instance ID from the input buffer
834 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
835 String preloadName = input.getVnfInstanceRequestInformation().getVnfInstanceName();
836 String preloadType = input.getVnfInstanceRequestInformation().getVnfModelId();
838 if (input.getSdncRequestHeader() != null) {
839 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
840 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
843 // Get vnf-instance-preload-data
844 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
845 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
848 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
849 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
851 // Get operational-data
852 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
853 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
855 // Set the serviceStatus based on input
856 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
857 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
860 // setup a service-data object builder
861 // ACTION vnf-topology-operationa
863 // USES sdnc-request-header;
864 // USES request-information;
865 // USES service-information;
866 // USES vnf-request-information
868 // USES vnf-topology-response-body;
869 // USES vnf-information
870 // USES service-information
872 // container service-data
873 // uses vnf-configuration-information;
876 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + viid + INPUT_STR + input);
877 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
878 VnfSdnUtil.toProperties(parms, inputBuilder.build());
880 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + viid + OPERATIONAL_DATA_STR + operDataBuilder
882 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
885 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
886 + vnfInstancePreloadDataBuilder.build());
887 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
889 // Call SLI sync method
890 // Get SvcLogicService reference
891 Properties respProps = null;
892 String errorCode = "200";
893 String errorMessage = null;
894 String ackFinal = "Y";
897 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
898 respProps = svcLogicClient
899 .execute(VNF_API, svcOperation, null, "sync", vnfInstanceServiceDataBuilder, parms);
901 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
904 } catch (SvcLogicException e) {
905 log.error("Caught exception executing service logic for " + svcOperation, e);
906 errorMessage = e.getMessage();
908 } catch (Exception e) {
910 errorMessage = e.getMessage();
911 log.error("Caught exception looking for service logic", e);
914 if (respProps != null) {
915 errorCode = respProps.getProperty("error-code");
916 errorMessage = respProps.getProperty("error-message");
917 ackFinal = respProps.getProperty("ack-final", "Y");
920 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
921 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
922 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
924 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
925 responseBuilder.setResponseCode(errorCode);
926 responseBuilder.setResponseMessage(errorMessage);
927 responseBuilder.setAckFinalIndicator(ackFinal);
928 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
929 vnfInstanceListBuilder.setVnfInstanceId(viid);
930 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
932 saveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
933 } catch (Exception e) {
934 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
936 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
937 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
938 .<VnfInstanceTopologyOperationOutput>status(true)
939 .withResult(responseBuilder.build())
942 return Futures.immediateFuture(rpcResult);
945 // Got success from SLI
947 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
948 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + viid + "] VnfInstanceServiceData: "
949 + vnfInstanceServiceData);
950 // svc-configuration-list
951 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
952 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
953 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
954 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
955 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
956 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
957 // Only update operational tree on Delete or Activate
958 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
959 .getSvcAction().equals(SvcAction.Activate)) {
960 log.info(UPDATING_OPERATIONAL_TREE_STR);
961 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
964 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
965 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
966 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
967 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
968 } catch (Exception e) {
969 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
970 responseBuilder.setResponseCode("500");
971 responseBuilder.setResponseMessage(e.toString());
972 responseBuilder.setAckFinalIndicator("Y");
973 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
974 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
975 .<VnfInstanceTopologyOperationOutput>status(true)
976 .withResult(responseBuilder.build())
979 return Futures.immediateFuture(rpcResult);
983 responseBuilder.setResponseCode(errorCode);
984 responseBuilder.setAckFinalIndicator(ackFinal);
985 if (errorMessage != null) {
986 responseBuilder.setResponseMessage(errorMessage);
988 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + viid + "] ");
989 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
991 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
992 .<VnfInstanceTopologyOperationOutput>status(true)
993 .withResult(responseBuilder.build())
996 return Futures.immediateFuture(rpcResult);
999 //1610 vf-module-topology-operation
1001 public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1002 VfModuleTopologyOperationInput input) {
1004 final String svcOperation = "vf-module-topology-operation";
1005 VfModuleServiceData vfModuleServiceData;
1006 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1007 Properties parms = new Properties();
1009 log.info(svcOperation + CALLED_STR);
1010 // create a new response object
1011 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1013 // Validate vf-module-id from vf-module-request-information
1014 if (input == null || input.getVfModuleRequestInformation() == null
1015 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1016 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1017 responseBuilder.setResponseCode("403");
1018 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1019 responseBuilder.setAckFinalIndicator("Y");
1020 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1021 .<VfModuleTopologyOperationOutput>status(true)
1022 .withResult(responseBuilder.build())
1025 return Futures.immediateFuture(rpcResult);
1028 // Grab the vf-module-request-information.vf-module-id from the input buffer
1029 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1030 String preloadName = input.getVfModuleRequestInformation().getVfModuleName();
1031 String preloadType = input.getVfModuleRequestInformation().getVfModuleModelId();
1033 // Make sure we have a valid siid
1034 if (vfid == null || vfid.length() == 0) {
1035 log.debug(EXITING_STR + svcOperation + " because of invalid vf-module-id");
1036 responseBuilder.setResponseCode("403");
1037 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1038 responseBuilder.setAckFinalIndicator("Y");
1039 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1040 .<VfModuleTopologyOperationOutput>status(true)
1041 .withResult(responseBuilder.build())
1044 return Futures.immediateFuture(rpcResult);
1047 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1048 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1050 if (viid == null || viid.length() == 0) {
1051 log.debug(EXITING_STR + svcOperation + " because of invalid vnf-instance-id");
1052 responseBuilder.setResponseCode("403");
1053 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
1054 responseBuilder.setAckFinalIndicator("Y");
1055 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1056 .<VfModuleTopologyOperationOutput>status(true)
1057 .withResult(responseBuilder.build())
1060 return Futures.immediateFuture(rpcResult);
1063 if (input.getSdncRequestHeader() != null) {
1064 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1065 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1068 // Get vf-module-preload-data
1069 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1070 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
1072 // Get vf-module-service-data
1073 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1074 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1076 // Get vf-module operation-data
1077 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1078 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1080 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1081 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1082 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1084 // vnf-instance operational-data
1085 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1086 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1088 // Set the serviceStatus based on input
1089 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1090 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1093 // setup a service-data object builder
1094 // ACTION vnf-topology-operation
1096 // USES request-information;
1097 // USES service-information;
1098 // USES vnf-request-information
1100 // USES vnf-information
1101 // USES service-information
1103 // container service-data
1105 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + vfid + INPUT_STR + input);
1106 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1107 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1109 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + vfid + "] vf-module operational-data: "
1110 + operDataBuilder.build());
1111 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1113 log.info(ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1114 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1115 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1117 log.info("Adding vnf-instance CONFIG data for " + svcOperation + " [" + viid + "] vnf-instance-service-data: "
1118 + vnfInstanceServiceDataBuilder.build());
1119 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1121 log.info("Adding vnf-instance OPERATIONAL data for " + svcOperation + " [" + viid
1122 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1123 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1125 // Call SLI sync method
1126 // Get SvcLogicService reference
1128 Properties respProps = null;
1129 String errorCode = "200";
1130 String errorMessage = null;
1131 String ackFinal = "Y";
1134 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1135 respProps = svcLogicClient
1136 .execute(VNF_API, svcOperation, null, "sync", vfModuleServiceDataBuilder, parms);
1138 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1141 } catch (SvcLogicException e) {
1142 log.error("Caught exception executing service logic for " + svcOperation, e);
1143 errorMessage = e.getMessage();
1145 } catch (Exception e) {
1147 errorMessage = e.getMessage();
1148 log.error("Caught exception looking for service logic", e);
1151 if (respProps != null) {
1152 errorCode = respProps.getProperty("error-code");
1153 errorMessage = respProps.getProperty("error-message");
1154 ackFinal = respProps.getProperty("ack-final", "Y");
1157 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1158 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1159 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1161 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1162 responseBuilder.setResponseCode(errorCode);
1163 responseBuilder.setResponseMessage(errorMessage);
1164 responseBuilder.setAckFinalIndicator(ackFinal);
1165 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1166 vfModuleListBuilder.setVfModuleId(vfid);
1167 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1169 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1170 } catch (Exception e) {
1171 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1173 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1174 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1175 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1178 return Futures.immediateFuture(rpcResult);
1181 // Got success from SLI
1182 // save vf-module-service-data in MD-SAL
1184 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1186 UPDATING_MD_SAL_STR + svcOperation + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1188 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1189 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1190 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1191 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1192 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1193 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1194 // Only update operational tree on Delete or Activate
1195 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1196 .getSvcAction().equals(SvcAction.Activate)) {
1197 log.info(UPDATING_OPERATIONAL_TREE_STR);
1198 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1201 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1202 vfModuleInformationBuilder.setVfModuleId(vfid);
1203 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1204 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1205 } catch (Exception e) {
1206 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1207 responseBuilder.setResponseCode("500");
1208 responseBuilder.setResponseMessage(e.toString());
1209 responseBuilder.setAckFinalIndicator("Y");
1210 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1211 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1212 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1215 return Futures.immediateFuture(rpcResult);
1219 responseBuilder.setResponseCode(errorCode);
1220 responseBuilder.setAckFinalIndicator(ackFinal);
1221 if (errorMessage != null) {
1222 responseBuilder.setResponseMessage(errorMessage);
1224 log.info("Updated vf-module in MD-SAL for " + svcOperation + " [" + vfid + "] ");
1225 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1227 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1228 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1230 return Futures.immediateFuture(rpcResult);
1234 public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
1235 VnfTopologyOperationInput input) {
1236 final String svcOperation = "vnf-topology-operation";
1237 ServiceData serviceData;
1238 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1239 Properties parms = new Properties();
1241 log.info(svcOperation + CALLED_STR);
1242 // create a new response object
1243 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1245 if (input == null || input.getServiceInformation() == null
1246 || input.getServiceInformation().getServiceInstanceId() == null
1247 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1248 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1249 responseBuilder.setResponseCode("403");
1250 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1251 responseBuilder.setAckFinalIndicator("Y");
1252 RpcResult<VnfTopologyOperationOutput> rpcResult =
1253 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1255 return Futures.immediateFuture(rpcResult);
1258 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1259 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1260 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1261 responseBuilder.setResponseCode("403");
1262 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1263 responseBuilder.setAckFinalIndicator("Y");
1264 RpcResult<VnfTopologyOperationOutput> rpcResult =
1265 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1267 return Futures.immediateFuture(rpcResult);
1270 // Grab the service instance ID from the input buffer
1271 String siid = input.getVnfRequestInformation().getVnfId();
1272 String preloadName = input.getVnfRequestInformation().getVnfName();
1273 String preloadType = input.getVnfRequestInformation().getVnfType();
1275 if (input.getSdncRequestHeader() != null) {
1276 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1277 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1280 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1281 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1283 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1284 getServiceData(siid, serviceDataBuilder);
1286 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1287 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1289 // Set the serviceStatus based on input
1290 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1291 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1294 // setup a service-data object builder
1295 // ACTION vnf-topology-operation
1297 // USES request-information;
1298 // USES vnf-request-information
1300 // USES vnf-information
1301 // USES service-information
1303 // container service-data
1304 // uses oper-status;
1306 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1307 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1308 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1310 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + siid + OPERATIONAL_DATA_STR + operDataBuilder
1312 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1315 "Adding CONFIG data for " + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1316 + preloadDataBuilder.build());
1317 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1319 // Call SLI sync method
1320 // Get SvcLogicService reference
1321 Properties respProps = null;
1322 String errorCode = "200";
1323 String errorMessage = null;
1324 String ackFinal = "Y";
1327 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1328 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", serviceDataBuilder, parms);
1330 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1333 } catch (SvcLogicException e) {
1334 log.error("Caught exception executing service logic for " + siid, e);
1335 errorMessage = e.getMessage();
1337 } catch (Exception e) {
1339 errorMessage = e.getMessage();
1340 log.error("Caught exception looking for service logic", e);
1343 if (respProps != null) {
1344 errorCode = respProps.getProperty("error-code");
1345 errorMessage = respProps.getProperty("error-message");
1346 ackFinal = respProps.getProperty("ack-final", "Y");
1349 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1350 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1351 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1353 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1354 responseBuilder.setResponseCode(errorCode);
1355 responseBuilder.setResponseMessage(errorMessage);
1356 responseBuilder.setAckFinalIndicator(ackFinal);
1357 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1358 vnfListBuilder.setVnfId(siid);
1359 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1361 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1362 } catch (Exception e) {
1363 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1365 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1366 RpcResult<VnfTopologyOperationOutput> rpcResult =
1367 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1369 return Futures.immediateFuture(rpcResult);
1372 // Got success from SLI
1374 serviceData = serviceDataBuilder.build();
1375 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + siid + "] ServiceData: " + serviceData);
1376 // svc-configuration-list
1377 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1378 vnfListBuilder.setServiceData(serviceData);
1379 vnfListBuilder.setVnfId(serviceData.getVnfId());
1380 siid = serviceData.getVnfId();
1381 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1382 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1383 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1384 // Only update operational tree on Delete or Activate
1385 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1386 log.info(UPDATING_OPERATIONAL_TREE_STR);
1387 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1388 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1389 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1390 log.info("Delete OPERATIONAL tree.");
1391 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1392 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1395 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1396 vnfInformationBuilder.setVnfId(siid);
1397 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1398 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1399 } catch (Exception e) {
1400 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1401 responseBuilder.setResponseCode("500");
1402 responseBuilder.setResponseMessage(e.toString());
1403 responseBuilder.setAckFinalIndicator("Y");
1404 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1405 RpcResult<VnfTopologyOperationOutput> rpcResult =
1406 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1408 return Futures.immediateFuture(rpcResult);
1412 responseBuilder.setResponseCode(errorCode);
1413 responseBuilder.setAckFinalIndicator(ackFinal);
1414 if (errorMessage != null) {
1415 responseBuilder.setResponseMessage(errorMessage);
1417 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1418 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1420 RpcResult<VnfTopologyOperationOutput> rpcResult =
1421 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1423 return Futures.immediateFuture(rpcResult);
1427 public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1428 NetworkTopologyOperationInput input) {
1430 final String svcOperation = "network-topology-operation";
1431 ServiceData serviceData;
1432 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1433 Properties parms = new Properties();
1435 log.info(svcOperation + CALLED_STR);
1436 // create a new response object
1437 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1439 if (input == null || input.getServiceInformation() == null
1440 || input.getServiceInformation().getServiceInstanceId() == null
1441 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1442 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1443 responseBuilder.setResponseCode("403");
1444 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1445 responseBuilder.setAckFinalIndicator("Y");
1446 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1447 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1450 return Futures.immediateFuture(rpcResult);
1453 if (input.getNetworkRequestInformation() == null
1454 || input.getNetworkRequestInformation().getNetworkName() == null) {
1455 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1456 responseBuilder.setResponseCode("403");
1457 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1458 responseBuilder.setAckFinalIndicator("Y");
1459 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1460 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1463 return Futures.immediateFuture(rpcResult);
1466 // Grab the service instance ID from the input buffer
1468 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1469 siid = input.getNetworkRequestInformation().getNetworkName();
1471 siid = input.getNetworkRequestInformation().getNetworkId();
1473 String preloadName = input.getNetworkRequestInformation().getNetworkName();
1474 String preloadType = input.getNetworkRequestInformation().getNetworkType();
1476 if (input.getSdncRequestHeader() != null) {
1477 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1478 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1481 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1482 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1484 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1485 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1486 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1488 // Call SLI sync method
1489 // Get SvcLogicService reference
1490 Properties respProps = null;
1491 String errorCode = "200";
1492 String errorMessage = null;
1493 String ackFinal = "Y";
1494 String networkId = "error";
1497 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1498 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1500 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1503 } catch (SvcLogicException e) {
1504 log.error("Caught exception executing service logic for " + svcOperation, e);
1505 errorMessage = e.getMessage();
1507 } catch (Exception e) {
1509 errorMessage = e.getMessage();
1510 log.error("Caught exception looking for service logic", e);
1513 if (respProps != null) {
1514 errorCode = respProps.getProperty("error-code");
1515 errorMessage = respProps.getProperty("error-message");
1516 ackFinal = respProps.getProperty("ack-final", "Y");
1517 networkId = respProps.getProperty("networkId", "0");
1520 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1521 responseBuilder.setResponseCode(errorCode);
1522 responseBuilder.setResponseMessage(errorMessage);
1523 responseBuilder.setAckFinalIndicator(ackFinal);
1525 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1527 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1528 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1531 return Futures.immediateFuture(rpcResult);
1534 // Got success from SLI
1536 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1537 networkInformationBuilder.setNetworkId(networkId);
1538 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1539 responseBuilder.setServiceInformation(input.getServiceInformation());
1540 } catch (IllegalStateException e) {
1541 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1542 responseBuilder.setResponseCode("500");
1543 responseBuilder.setResponseMessage(e.toString());
1544 responseBuilder.setAckFinalIndicator("Y");
1545 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1546 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1547 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1550 return Futures.immediateFuture(rpcResult);
1554 responseBuilder.setResponseCode(errorCode);
1555 responseBuilder.setAckFinalIndicator(ackFinal);
1556 if (errorMessage != null) {
1557 responseBuilder.setResponseMessage(errorMessage);
1559 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1560 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1562 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1563 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1565 return Futures.immediateFuture(rpcResult);
1569 public ListenableFuture<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1570 PreloadVnfTopologyOperationInput input) {
1572 final String svcOperation = "preload-vnf-topology-operation";
1573 PreloadData preloadData;
1574 Properties parms = new Properties();
1576 log.info(svcOperation + CALLED_STR);
1577 // create a new response object
1578 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1580 // Result from savePreloadData
1582 if (input == null || input.getVnfTopologyInformation() == null
1583 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1584 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1585 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1586 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vnf-name or vnf-type");
1587 responseBuilder.setResponseCode("403");
1588 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1589 responseBuilder.setAckFinalIndicator("Y");
1590 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1591 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1593 return Futures.immediateFuture(rpcResult);
1596 // Grab the name and type from the input buffer
1597 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1598 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1600 // Make sure we have a preload_name and preload_type
1601 if (preloadName == null || preloadName.length() == 0) {
1602 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1603 responseBuilder.setResponseCode("403");
1604 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1605 responseBuilder.setAckFinalIndicator("Y");
1606 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1607 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1609 return Futures.immediateFuture(rpcResult);
1612 if (preloadType == null || preloadType.length() == 0) {
1613 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1614 responseBuilder.setResponseCode("403");
1615 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1616 responseBuilder.setAckFinalIndicator("Y");
1617 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1618 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1620 return Futures.immediateFuture(rpcResult);
1623 if (input.getSdncRequestHeader() != null) {
1624 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1625 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1628 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1629 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1630 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1631 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1634 // setup a preload-data object builder
1635 // ACTION vnf-topology-operation
1637 // USES request-information;
1638 // uses vnf-topology-information;
1641 // container preload-data
1643 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1644 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1645 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1646 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1647 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1648 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1650 // Call SLI sync method
1651 // Get SvcLogicService reference
1652 Properties respProps = null;
1653 String errorCode = "200";
1654 String errorMessage = null;
1655 String ackFinal = "Y";
1658 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1659 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1661 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1664 } catch (SvcLogicException e) {
1665 log.error("Caught exception executing service logic for " + svcOperation, e);
1666 errorMessage = e.getMessage();
1668 } catch (Exception e) {
1670 errorMessage = e.getMessage();
1671 log.error("Caught exception looking for service logic", e);
1674 if (respProps != null) {
1675 errorCode = respProps.getProperty("error-code");
1676 errorMessage = respProps.getProperty("error-message");
1677 ackFinal = respProps.getProperty("ack-final", "Y");
1680 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1682 responseBuilder.setResponseCode(errorCode);
1683 responseBuilder.setResponseMessage(errorMessage);
1684 responseBuilder.setAckFinalIndicator(ackFinal);
1686 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1687 preloadVnfListBuilder.setVnfName(preloadName);
1688 preloadVnfListBuilder.setVnfType(preloadType);
1689 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1691 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
1692 + errorCode + "', Reason: '" + errorMessage + "'");
1694 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1695 } catch (Exception e) {
1697 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1700 log.debug(SENDING_SUCCESS_RPC);
1701 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1702 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1704 return Futures.immediateFuture(rpcResult);
1707 // Got success from SLI
1709 preloadData = preloadDataBuilder.build();
1711 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
1713 // svc-configuration-list
1714 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1715 preloadVnfListBuilder.setVnfName(preloadName);
1716 preloadVnfListBuilder.setVnfType(preloadType);
1717 preloadVnfListBuilder.setPreloadData(preloadData);
1719 // SDNGC-989 set merge flag to false
1720 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1721 log.info(UPDATING_OPERATIONAL_TREE_STR);
1722 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1723 } catch (Exception e) {
1724 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1726 responseBuilder.setResponseCode("500");
1727 responseBuilder.setResponseMessage(e.toString());
1728 responseBuilder.setAckFinalIndicator("Y");
1729 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
1730 + responseBuilder.build());
1731 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1732 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1734 return Futures.immediateFuture(rpcResult);
1738 responseBuilder.setResponseCode(errorCode);
1739 responseBuilder.setAckFinalIndicator(ackFinal);
1740 if (errorMessage != null) {
1741 responseBuilder.setResponseMessage(errorMessage);
1743 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
1745 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
1748 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1749 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1751 return Futures.immediateFuture(rpcResult);
1754 //1610 preload-vnf-instance-topology-operation
1756 public ListenableFuture<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1757 PreloadVnfInstanceTopologyOperationInput input) {
1759 final String svcOperation = "preload-vnf-instance-topology-operation";
1760 VnfInstancePreloadData vnfInstancePreloadData;
1761 Properties parms = new Properties();
1763 log.info(svcOperation + CALLED_STR);
1764 // create a new response object
1765 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1766 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1768 if (input == null || input.getVnfInstanceTopologyInformation() == null
1769 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1770 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1771 log.debug(EXITING_STR + svcOperation
1772 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1773 responseBuilder.setResponseCode("403");
1774 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1775 responseBuilder.setAckFinalIndicator("Y");
1776 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1777 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1778 .withResult(responseBuilder.build()).build();
1779 return Futures.immediateFuture(rpcResult);
1782 // Grab the name and type from the input buffer
1783 String preloadName =
1784 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1785 String preloadType = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1787 // Make sure we have a preloadName and preloadType
1788 if (preloadName == null || preloadName.length() == 0) {
1789 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1790 responseBuilder.setResponseCode("403");
1791 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1792 responseBuilder.setAckFinalIndicator("Y");
1793 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1794 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1795 .withResult(responseBuilder.build()).build();
1796 return Futures.immediateFuture(rpcResult);
1799 if (preloadType == null || preloadType.length() == 0) {
1800 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1801 responseBuilder.setResponseCode("403");
1802 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1803 responseBuilder.setAckFinalIndicator("Y");
1804 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1805 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1806 .withResult(responseBuilder.build()).build();
1807 return Futures.immediateFuture(rpcResult);
1810 if (input.getSdncRequestHeader() != null) {
1811 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1812 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1815 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1816 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1817 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
1818 getVnfInstancePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1821 // setup a preload-data object builder
1822 // ACTION vnf-topology-operation
1824 // uses vnf-topology-information;
1826 // container preload-data
1828 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1829 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
1830 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
1831 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1832 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1833 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1834 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1836 // Call SLI sync method
1837 // Get SvcLogicService reference
1838 Properties respProps = null;
1839 String errorCode = "200";
1840 String errorMessage = null;
1841 String ackFinal = "Y";
1844 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1845 respProps = svcLogicClient
1846 .execute(VNF_API, svcOperation, null, "sync", vnfInstancePreloadDataBuilder, parms);
1848 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1851 } catch (SvcLogicException e) {
1852 log.error("Caught exception executing service logic for " + svcOperation, e);
1853 errorMessage = e.getMessage();
1855 } catch (Exception e) {
1857 errorMessage = e.getMessage();
1858 log.error("Caught exception looking for service logic", e);
1861 if (respProps != null) {
1862 errorCode = respProps.getProperty("error-code");
1863 errorMessage = respProps.getProperty("error-message");
1864 ackFinal = respProps.getProperty("ack-final", "Y");
1867 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1869 responseBuilder.setResponseCode(errorCode);
1870 responseBuilder.setResponseMessage(errorMessage);
1871 responseBuilder.setAckFinalIndicator(ackFinal);
1873 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
1874 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
1875 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
1876 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
1878 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
1879 + errorCode + "', Reason: '" + errorMessage + "'");
1881 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
1882 LogicalDatastoreType.CONFIGURATION);
1883 } catch (Exception e) {
1885 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1888 log.debug(SENDING_SUCCESS_RPC);
1889 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1890 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1891 .withResult(responseBuilder.build()).build();
1892 return Futures.immediateFuture(rpcResult);
1895 // Got success from SLI
1897 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
1899 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
1900 + vnfInstancePreloadData);
1901 // svc-configuration-list
1902 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
1903 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
1904 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
1905 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
1907 // SDNGC-989 set merge flag to false
1908 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
1909 LogicalDatastoreType.CONFIGURATION);
1910 log.info(UPDATING_OPERATIONAL_TREE_STR);
1911 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1912 } catch (Exception e) {
1913 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1915 responseBuilder.setResponseCode("500");
1916 responseBuilder.setResponseMessage(e.toString());
1917 responseBuilder.setAckFinalIndicator("Y");
1918 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
1919 + responseBuilder.build());
1920 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1921 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
1922 .withResult(responseBuilder.build()).build();
1923 return Futures.immediateFuture(rpcResult);
1927 responseBuilder.setResponseCode(errorCode);
1928 responseBuilder.setAckFinalIndicator(ackFinal);
1929 if (errorMessage != null) {
1930 responseBuilder.setResponseMessage(errorMessage);
1932 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
1934 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
1937 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1938 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1940 return Futures.immediateFuture(rpcResult);
1944 //1610 preload-vf-module-topology-operation
1946 public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
1947 PreloadVfModuleTopologyOperationInput input) {
1949 final String svcOperation = "preload-vf-module-topology-operation";
1950 VfModulePreloadData vfModulePreloadData;
1951 Properties parms = new Properties();
1953 log.info(svcOperation + CALLED_STR);
1954 // create a new response object
1955 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
1956 new PreloadVfModuleTopologyOperationOutputBuilder();
1958 // Result from savePreloadData
1960 if (input == null || input.getVfModuleTopologyInformation() == null
1961 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
1962 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
1963 log.debug(EXITING_STR + svcOperation
1964 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
1965 responseBuilder.setResponseCode("403");
1966 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
1967 responseBuilder.setAckFinalIndicator("Y");
1968 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
1969 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
1970 .withResult(responseBuilder.build()).build();
1971 return Futures.immediateFuture(rpcResult);
1974 // Grab the name and type from the input buffer
1975 String preloadName = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
1976 String preloadType = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
1978 // Make sure we have a preloadName and preloadType
1979 if (preloadName == null || preloadName.length() == 0) {
1980 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1981 responseBuilder.setResponseCode("403");
1982 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1983 responseBuilder.setAckFinalIndicator("Y");
1984 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
1985 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
1986 .withResult(responseBuilder.build()).build();
1987 return Futures.immediateFuture(rpcResult);
1989 if (preloadType == null || preloadType.length() == 0) {
1990 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1991 responseBuilder.setResponseCode("403");
1992 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1993 responseBuilder.setAckFinalIndicator("Y");
1994 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
1995 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
1996 .withResult(responseBuilder.build()).build();
1997 return Futures.immediateFuture(rpcResult);
2000 if (input.getSdncRequestHeader() != null) {
2001 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2002 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2005 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2006 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
2007 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2008 getVfModulePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2011 // setup a preload-data object builder
2012 // ACTION vnf-topology-operation
2014 // USES request-information;
2015 // uses vnf-topology-information;
2018 // container preload-data
2021 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2022 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2023 new PreloadVfModuleTopologyOperationInputBuilder(input);
2024 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2025 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2026 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2027 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2029 // Call SLI sync method
2030 // Get SvcLogicService reference
2031 Properties respProps = null;
2032 String errorCode = "200";
2033 String errorMessage = null;
2034 String ackFinal = "Y";
2037 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2038 respProps = svcLogicClient
2039 .execute(VNF_API, svcOperation, null, "sync", vfModulePreloadDataBuilder, parms);
2041 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2044 } catch (SvcLogicException e) {
2045 log.error("Caught exception executing service logic for " + svcOperation, e);
2046 errorMessage = e.getMessage();
2049 } catch (Exception e) {
2051 errorMessage = e.getMessage();
2052 log.error("Caught exception looking for service logic", e);
2055 if (respProps != null) {
2056 errorCode = respProps.getProperty("error-code");
2057 errorMessage = respProps.getProperty("error-message");
2058 ackFinal = respProps.getProperty("ack-final", "Y");
2061 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2063 responseBuilder.setResponseCode(errorCode);
2064 responseBuilder.setResponseMessage(errorMessage);
2065 responseBuilder.setAckFinalIndicator(ackFinal);
2067 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2068 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2069 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2070 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2072 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2073 + errorCode + "', Reason: '" + errorMessage + "'");
2075 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2076 } catch (Exception e) {
2078 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2081 log.debug(SENDING_SUCCESS_RPC);
2082 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2083 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2084 .withResult(responseBuilder.build()).build();
2085 return Futures.immediateFuture(rpcResult);
2088 // Got success from SLI
2090 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2092 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2093 + vfModulePreloadData);
2094 // svc-configuration-list
2095 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2096 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2097 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2098 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2100 // SDNGC-989 set merge flag to false
2101 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2102 log.info(UPDATING_OPERATIONAL_TREE_STR);
2103 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2104 } catch (Exception e) {
2105 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2107 responseBuilder.setResponseCode("500");
2108 responseBuilder.setResponseMessage(e.toString());
2109 responseBuilder.setAckFinalIndicator("Y");
2110 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2111 + responseBuilder.build());
2112 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2113 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2114 .withResult(responseBuilder.build()).build();
2115 return Futures.immediateFuture(rpcResult);
2119 responseBuilder.setResponseCode(errorCode);
2120 responseBuilder.setAckFinalIndicator(ackFinal);
2121 if (errorMessage != null) {
2122 responseBuilder.setResponseMessage(errorMessage);
2124 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2126 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2129 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2130 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2132 return Futures.immediateFuture(rpcResult);
2137 public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2138 PreloadNetworkTopologyOperationInput input) {
2140 final String svcOperation = "preload-network-topology-operation";
2141 PreloadData preloadData = null;
2142 Properties parms = new Properties();
2144 log.info(svcOperation + CALLED_STR);
2145 // create a new response object
2146 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2147 new PreloadNetworkTopologyOperationOutputBuilder();
2149 // Result from savePreloadData
2151 if (input == null || input.getNetworkTopologyInformation() == null
2152 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2153 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2154 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2155 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or" +
2156 " empty network-name or network-type");
2157 responseBuilder.setResponseCode("403");
2158 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2159 responseBuilder.setAckFinalIndicator("Y");
2160 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2161 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2163 return Futures.immediateFuture(rpcResult);
2166 // Grab the name and type from the input buffer
2167 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2168 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2170 // Make sure we have a preloadName and preloadType
2171 if (preloadName == null || preloadName.length() == 0) {
2172 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2173 responseBuilder.setResponseCode("403");
2174 responseBuilder.setResponseMessage("input, invalid preload-name");
2175 responseBuilder.setAckFinalIndicator("Y");
2176 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2177 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2179 return Futures.immediateFuture(rpcResult);
2182 if (preloadType == null || preloadType.length() == 0) {
2183 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2184 responseBuilder.setResponseCode("403");
2185 responseBuilder.setResponseMessage("input, invalid preload-type");
2186 responseBuilder.setAckFinalIndicator("Y");
2187 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2188 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2190 return Futures.immediateFuture(rpcResult);
2193 if (input.getSdncRequestHeader() != null) {
2194 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2195 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2198 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2199 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2201 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2202 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2205 // setup a preload-data object builder
2206 // ACTION vnf-topology-operation
2208 // USES request-information;
2209 // uses vnf-topology-information;
2212 // container preload-data
2214 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2215 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2216 new PreloadNetworkTopologyOperationInputBuilder(input);
2217 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2218 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2219 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2220 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2222 // Call SLI sync method
2223 // Get SvcLogicService reference
2224 Properties respProps = null;
2225 String errorCode = "200";
2226 String errorMessage = null;
2227 String ackFinal = "Y";
2230 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2231 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
2233 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2236 } catch (SvcLogicException e) {
2237 log.error("Caught exception executing service logic for " + svcOperation, e);
2238 errorMessage = e.getMessage();
2240 } catch (Exception e) {
2242 errorMessage = e.getMessage();
2243 log.error("Caught exception looking for service logic", e);
2246 if (respProps != null) {
2247 errorCode = respProps.getProperty("error-code");
2248 errorMessage = respProps.getProperty("error-message");
2249 ackFinal = respProps.getProperty("ack-final", "Y");
2252 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2253 responseBuilder.setResponseCode(errorCode);
2254 responseBuilder.setResponseMessage(errorMessage);
2255 responseBuilder.setAckFinalIndicator(ackFinal);
2257 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2258 preloadVnfListBuilder.setVnfName(preloadName);
2259 preloadVnfListBuilder.setVnfType(preloadType);
2260 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2262 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2263 + errorCode + "', Reason: '" + errorMessage + "'");
2265 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2266 } catch (Exception e) {
2268 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2272 log.debug(SENDING_SUCCESS_RPC);
2273 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2274 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2276 return Futures.immediateFuture(rpcResult);
2279 // Got success from SLI
2281 preloadData = preloadDataBuilder.build();
2283 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2285 // svc-configuration-list
2286 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2287 preloadVnfListBuilder.setVnfName(preloadName);
2288 preloadVnfListBuilder.setVnfType(preloadType);
2289 preloadVnfListBuilder.setPreloadData(preloadData);
2291 // SDNGC-989 set merge flag to false
2292 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2293 log.info(UPDATING_OPERATIONAL_TREE_STR);
2294 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2295 } catch (Exception e) {
2296 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2298 responseBuilder.setResponseCode("500");
2299 responseBuilder.setResponseMessage(e.toString());
2300 responseBuilder.setAckFinalIndicator("Y");
2301 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2302 + responseBuilder.build());
2303 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2304 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2305 .withResult(responseBuilder.build()).build();
2306 return Futures.immediateFuture(rpcResult);
2310 responseBuilder.setResponseCode(errorCode);
2311 responseBuilder.setAckFinalIndicator(ackFinal);
2312 if (errorMessage != null) {
2313 responseBuilder.setResponseMessage(errorMessage);
2315 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2317 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2320 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2321 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2323 return Futures.immediateFuture(rpcResult);