2 * ============LICENSE_START=======================================================
3 * ONAP : ccsdk features
4 * ================================================================================
5 * Copyright (C) 2022 highstreet technologies GmbH Intellectual Property.
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.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.impl.interfaces;
24 import com.google.common.collect.Sets;
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.List;
28 import java.util.Objects;
29 import java.util.Optional;
30 import org.eclipse.jdt.annotation.NonNull;
31 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.impl.dataprovider.InternalDataModelSeverity;
32 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.impl.pm.PerformanceDataAirInterface;
33 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.impl.util.Debug;
34 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.impl.util.Onf14DMDOMUtility;
35 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.impl.util.Onf14DevicemanagerQNames;
36 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.notifications.Onf14DomAirInterfaceNotificationListener;
37 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.notifications.Onf14DomEthernetContainerNotificationListener;
38 import org.onap.ccsdk.features.sdnr.wt.devicemanager.onf14.dom.notifications.Onf14DomWireInterfaceNotificationListener;
39 import org.onap.ccsdk.features.sdnr.wt.devicemanager.service.DeviceManagerServiceProvider;
40 import org.onap.ccsdk.features.sdnr.wt.devicemanager.service.FaultService;
41 import org.onap.ccsdk.features.sdnr.wt.devicemanager.types.FaultData;
42 import org.onap.ccsdk.features.sdnr.wt.devicemanager.types.PerformanceDataLtp;
43 import org.onap.ccsdk.features.sdnr.wt.netconfnodestateservice.NetconfDomAccessor;
44 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
46 import org.opendaylight.yangtools.yang.common.QName;
47 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
48 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
51 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
52 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
56 import org.slf4j.Logger;
57 import org.slf4j.LoggerFactory;
60 * Notifications streams provided by device NTSSim ONF14
61 * Stream{getName=StreamNameType{_value=nc-notifications}, isReplaySupport=true, augmentation=[]},
62 * Stream{getName=StreamNameType{_value=hybrid-mw-structure-2-0}, isReplaySupport=true, augmentation=[]},
63 * Stream{getName=StreamNameType{_value=vlan-interface-1-0}, isReplaySupport=true, augmentation=[]},
64 * Stream{getName=StreamNameType{_value=tdm-container-2-0}, isReplaySupport=true, augmentation=[]},
65 * Stream{getName=StreamNameType{_value=ethernet-container-2-0}, isReplaySupport=true, augmentation=[]},
66 * Stream{getName=StreamNameType{_value=ietf-yang-library}, isReplaySupport=false, augmentation=[]},
67 * Stream{getDescription=Default NETCONF stream containing all the Event Notifications., getName=StreamNameType{_value=NETCONF}, isReplaySupport=true, augmentation=[]},
68 * Stream{getName=StreamNameType{_value=vlan-fd-1-0}, isReplaySupport=true, augmentation=[]},
69 * Stream{getName=StreamNameType{_value=wire-interface-2-0}, isReplaySupport=true, augmentation=[]},
70 * Stream{getName=StreamNameType{_value=mac-fd-1-0}, isReplaySupport=true, augmentation=[]},
71 * Stream{getName=StreamNameType{_value=co-channel-profile-1-0}, isReplaySupport=true, augmentation=[]},
72 * Stream{getName=StreamNameType{_value=mac-interface-1-0}, isReplaySupport=true, augmentation=[]},
73 * Stream{getName=StreamNameType{_value=ietf-keystore}, isReplaySupport=true, augmentation=[]},
74 * Stream{getName=StreamNameType{_value=pure-ethernet-structure-2-0}, isReplaySupport=true, augmentation=[]},
75 * Stream{getName=StreamNameType{_value=ietf-netconf-notifications}, isReplaySupport=true, augmentation=[]},
76 * Stream{getName=StreamNameType{_value=mac-fc-1-0}, isReplaySupport=true, augmentation=[]},
77 * Stream{getName=StreamNameType{_value=wred-profile-1-0}, isReplaySupport=true, augmentation=[]},
78 * Stream{getName=StreamNameType{_value=air-interface-2-0}, isReplaySupport=true, augmentation=[]},
79 * Stream{getName=StreamNameType{_value=ip-interface-1-0}, isReplaySupport=true, augmentation=[]},
80 * Stream{getName=StreamNameType{_value=qos-profile-1-0}, isReplaySupport=true, augmentation=[]},
81 * Stream{getName=StreamNameType{_value=vlan-fc-1-0}, isReplaySupport=true, augmentation=[]},
82 * Stream{getName=StreamNameType{_value=l-3vpn-profile-1-0}, isReplaySupport=true, augmentation=[]}]
85 public class Onf14DomInterfacePacManager {
87 private static final Logger log = LoggerFactory.getLogger(Onf14DomInterfacePacManager.class);
89 private static final YangInstanceIdentifier LTP_IID =
90 YangInstanceIdentifier.builder().node(Onf14DevicemanagerQNames.CORE_MODEL_CONTROL_CONSTRUCT_CONTAINER)
91 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP).build();
93 private final NetconfDomAccessor netconfDomAccessor;
94 private final @NonNull DeviceManagerServiceProvider serviceProvider;
96 // air interface related members
97 private final List<TechnologySpecificPacKeys> airInterfaceList = new ArrayList<>();
99 private final Onf14DomAirInterfaceNotificationListener airInterfaceNotificationListener;
101 // ethernet container related members
102 private final List<TechnologySpecificPacKeys> ethernetContainerList = new ArrayList<>();
104 private final Onf14DomEthernetContainerNotificationListener ethernetContainerNotificationListener;
106 // wire interface related members
107 private final List<TechnologySpecificPacKeys> wireInterfaceList = new ArrayList<>();
109 private final Onf14DomWireInterfaceNotificationListener wireInterfaceNotificationListener;
111 private final @NonNull FaultService faultService;
113 public Onf14DomInterfacePacManager(@NonNull NetconfDomAccessor netconfDomAccessor,
114 @NonNull DeviceManagerServiceProvider serviceProvider) {
116 this.netconfDomAccessor = Objects.requireNonNull(netconfDomAccessor);
117 this.serviceProvider = Objects.requireNonNull(serviceProvider);
118 this.faultService = Objects.requireNonNull(serviceProvider.getFaultService());
120 this.airInterfaceNotificationListener =
121 new Onf14DomAirInterfaceNotificationListener(netconfDomAccessor, serviceProvider);
122 this.ethernetContainerNotificationListener =
123 new Onf14DomEthernetContainerNotificationListener(netconfDomAccessor, serviceProvider);
124 this.wireInterfaceNotificationListener =
125 new Onf14DomWireInterfaceNotificationListener(netconfDomAccessor, serviceProvider);
128 public void register() {
129 // storing all the LTP UUIDs internally, for later usage, for air-interface and
130 // ethernet-container and wire-interface
132 readAndWriteInterfaceCurrentProblems();
133 registerForNotifications();
136 public List<TechnologySpecificPacKeys> getAirInterfaceList() {
137 return airInterfaceList;
140 public PerformanceDataLtp readAirInterfaceHistoricalPerformanceData(String ltpUuid, String localId,
141 PerformanceDataLtp res) {
142 log.debug("Get historical performance data for class {} from mountpoint {} for LTP uuid {} and local-id {}",
143 Onf14DevicemanagerQNames.AIR_INTERFACE_2_0_MODULE, netconfDomAccessor.getNodeId().getValue(), ltpUuid,
146 // constructing the IID needs the augmentation exposed by the air-interface-2-0
149 InstanceIdentifierBuilder layerProtocolIID =
150 YangInstanceIdentifier.builder().node(Onf14DevicemanagerQNames.CORE_MODEL_CONTROL_CONSTRUCT_CONTAINER)
151 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP)
152 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP,
153 QName.create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP, "uuid").intern(), ltpUuid)
154 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL)
155 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, QName
156 .create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, "local-id").intern(),
160 AugmentationIdentifier airInterfacePacIID = YangInstanceIdentifier.AugmentationIdentifier
161 .create(Sets.newHashSet(Onf14DevicemanagerQNames.AIR_INTERFACE_PAC));
163 InstanceIdentifierBuilder augmentedAirInterfacePacIID =
164 YangInstanceIdentifier.builder(layerProtocolIID.build()).node(airInterfacePacIID);
166 // reading historical performance list for this specific LTP and LP
167 Optional<NormalizedNode> airInterfacePacDataOpt =
168 netconfDomAccessor.readDataNode(LogicalDatastoreType.OPERATIONAL, augmentedAirInterfacePacIID.build());
169 log.debug("Performance Data = {}", airInterfacePacDataOpt.get().body());
170 if (airInterfacePacDataOpt.isPresent()) {
171 AugmentationNode airInterfacePacData = (AugmentationNode) airInterfacePacDataOpt.get();
172 ContainerNode cn = (ContainerNode) airInterfacePacData
173 .childByArg(new NodeIdentifier(Onf14DevicemanagerQNames.AIR_INTERFACE_PAC));
175 ContainerNode airIntfHistPerf = (ContainerNode) cn
176 .childByArg(new NodeIdentifier(Onf14DevicemanagerQNames.AIR_INTERFACE_HISTORICAL_PERFORMANCES));
177 if (airIntfHistPerf != null) {
178 MapNode airInterfaceHistoricalPerformanceList = (MapNode) airIntfHistPerf.childByArg(
179 new NodeIdentifier(Onf14DevicemanagerQNames.AIR_INTERFACE_HISTORICAL_PERFORMANCES_LIST));
180 if (airInterfaceHistoricalPerformanceList != null) {
181 Collection<MapEntryNode> airInterfaceHistoricalPerfCollection =
182 airInterfaceHistoricalPerformanceList.body();
183 for (MapEntryNode airInterfaceHistPerf : airInterfaceHistoricalPerfCollection) {
184 res.add(new PerformanceDataAirInterface(netconfDomAccessor.getNodeId(), ltpUuid, localId,
185 airInterfaceHistPerf));
189 log.debug("DBRead Id {} empty CurrentProblemList", ltpUuid);
197 private void readAndWriteInterfaceCurrentProblems() {
198 // Read all fault data
199 FaultData resultList = new FaultData();
201 readAllAirInterfaceCurrentProblems(resultList);
202 problems = resultList.size();
203 log.debug("NETCONF read air interface current problems completed. Got back {} problems.", problems);
206 readAllEthernetContainerCurrentProblems(resultList);
207 problems = resultList.size() - problems;
208 log.debug("NETCONF read current problems completed. Got back {} problems.", problems);
210 readAllWireInterfaceCurrentProblems(resultList);
211 problems = resultList.size();
212 log.debug("NETCONF read wire interface current problems completed. Got back {} problems.", problems);
215 if (resultList.size() > 0) {
216 faultService.initCurrentProblemStatus(netconfDomAccessor.getNodeId(), resultList);
217 log.debug("DB write current problems completed");
222 private void readKeys() {
223 Optional<NormalizedNode> ltpData = readLtpData(netconfDomAccessor);
224 log.debug("LTP Data is - {}", ltpData);
225 if (ltpData.isPresent()) {
227 MapNode ccLtp = (MapNode) ltpData.get();
229 log.debug("Iterating the LTP list for node {}", netconfDomAccessor.getNodeId().getValue());
230 Collection<MapEntryNode> ltpList = ccLtp.body();
232 // iterating all the Logical Termination Point list
233 for (MapEntryNode ltp : ltpList) {
234 MapNode lpList = (MapNode) ltp
235 .childByArg(new NodeIdentifier(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL));
236 // the Layer Protocol list should contain only one item, since we have an 1:1
237 // relationship between the LTP and the LP
238 if (lpList != null && lpList.size() != 1) {
239 log.debug("Layer protocol has no 1:1 relationship with the LTP.");
242 // accessing the LP, which should be only 1
243 Collection<MapEntryNode> lp = lpList.body();
244 for (MapEntryNode lpEntry : lp) {
245 String layerProtocolName = Onf14DMDOMUtility.getLeafValue(lpEntry,
247 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL_NAME);
248 if (layerProtocolName != null) {
249 // if the LTP has an airInterface technology extension, the layer protocol name
251 if (layerProtocolName.contains("LAYER_PROTOCOL_NAME_TYPE_AIR_LAYER")) {
252 TechnologySpecificPacKeys airInterfaceKey = new TechnologySpecificPacKeys(
253 Onf14DMDOMUtility.getLeafValue(ltp,
254 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_UUID),
255 Onf14DMDOMUtility.getLeafValue(lpEntry,
256 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL_LOCAL_ID));
257 airInterfaceList.add(airInterfaceKey);
258 log.debug("Adding Ltp with uuid {} and local-id {} to the air-interface list",
259 Onf14DMDOMUtility.getLeafValue(ltp,
260 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_UUID),
261 Onf14DMDOMUtility.getLeafValue(lpEntry,
262 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL_LOCAL_ID));
264 // if the LTP has an ethernetContainer technology extension, the layer protocol
265 // name is ethernet-container-layer
266 else if (layerProtocolName.contains("LAYER_PROTOCOL_NAME_TYPE_ETHERNET_CONTAINER_LAYER")) {
267 TechnologySpecificPacKeys ethernetContainerKey = new TechnologySpecificPacKeys(
268 Onf14DMDOMUtility.getLeafValue(ltp,
269 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_UUID),
270 Onf14DMDOMUtility.getLeafValue(lpEntry,
271 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL_LOCAL_ID));
272 ethernetContainerList.add(ethernetContainerKey);
273 log.debug("Adding Ltp with uuid {} and local-id {} to the ethernet-container list",
274 Onf14DMDOMUtility.getLeafValue(ltp,
275 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_UUID),
276 Onf14DMDOMUtility.getLeafValue(lpEntry,
277 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL_LOCAL_ID));
278 } else if (layerProtocolName.contains("LAYER_PROTOCOL_NAME_TYPE_WIRE_LAYER")) {
279 TechnologySpecificPacKeys wireInterfaceKey = new TechnologySpecificPacKeys(
280 Onf14DMDOMUtility.getLeafValue(ltp,
281 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_UUID),
282 Onf14DMDOMUtility.getLeafValue(lpEntry,
283 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL_LOCAL_ID));
284 wireInterfaceList.add(wireInterfaceKey);
285 log.debug("Adding Ltp with uuid {} and local-id {} to the wire-interface list",
286 Onf14DMDOMUtility.getLeafValue(ltp,
287 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_UUID),
288 Onf14DMDOMUtility.getLeafValue(lpEntry,
289 Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL_LOCAL_ID));
298 private void readAllAirInterfaceCurrentProblems(FaultData resultList) {
300 int idxStart; // Start index for debug messages
302 for (TechnologySpecificPacKeys key : airInterfaceList) {
303 idxStart = resultList.size();
305 readAirInterfaceCurrentProblemForLtp(key.getLtpUuid(), key.getLocalId(), resultList);
306 Debug.debugResultList(key.getLtpUuid(), resultList, idxStart);
310 private void readAllEthernetContainerCurrentProblems(FaultData resultList) {
312 int idxStart; // Start index for debug messages
314 for (TechnologySpecificPacKeys key : ethernetContainerList) {
315 idxStart = resultList.size();
317 readEthernetContainerCurrentProblemForLtp(key.getLtpUuid(), key.getLocalId(), resultList);
318 Debug.debugResultList(key.getLtpUuid(), resultList, idxStart);
322 private void readAllWireInterfaceCurrentProblems(FaultData resultList) {
324 int idxStart; // Start index for debug messages
326 for (TechnologySpecificPacKeys key : wireInterfaceList) {
327 idxStart = resultList.size();
329 readWireInterfaceCurrentProblemForLtp(key.getLtpUuid(), key.getLocalId(), resultList);
330 Debug.debugResultList(key.getLtpUuid(), resultList, idxStart);
334 private void readAirInterfaceCurrentProblemForLtp(String ltpUuid, String localId, FaultData resultList) {
336 log.debug("DBRead Get current problems for class {} from mountpoint {} for LTP uuid {} and local-id {}",
337 Onf14DevicemanagerQNames.AIR_INTERFACE_2_0_MODULE, netconfDomAccessor.getNodeId().getValue(), ltpUuid,
340 // constructing the IID needs the augmentation exposed by the air-interface-2-0
343 InstanceIdentifierBuilder layerProtocolIID =
344 YangInstanceIdentifier.builder().node(Onf14DevicemanagerQNames.CORE_MODEL_CONTROL_CONSTRUCT_CONTAINER)
345 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP)
346 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP,
347 QName.create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP, "uuid").intern(), ltpUuid)
348 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL)
349 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, QName
350 .create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, "local-id").intern(),
354 AugmentationIdentifier airInterfacePacIID = YangInstanceIdentifier.AugmentationIdentifier
355 .create(Sets.newHashSet(Onf14DevicemanagerQNames.AIR_INTERFACE_PAC));
357 InstanceIdentifierBuilder augmentedAirInterfacePacIID =
358 YangInstanceIdentifier.builder(layerProtocolIID.build()).node(airInterfacePacIID);
360 // reading all the current-problems list for this specific LTP and LP
361 Optional<NormalizedNode> airInterfacePacDataOpt =
362 netconfDomAccessor.readDataNode(LogicalDatastoreType.OPERATIONAL, augmentedAirInterfacePacIID.build());
364 if (airInterfacePacDataOpt.isPresent()) {
365 AugmentationNode airInterfacePacData = (AugmentationNode) airInterfacePacDataOpt.get();
366 MapNode airInterfaceCurrentProblemsList = (MapNode) airInterfacePacData
367 .childByArg(new NodeIdentifier(Onf14DevicemanagerQNames.AIR_INTERFACE_CURRENT_PROBLEMS_LIST));
368 if (airInterfaceCurrentProblemsList != null) {
369 Collection<MapEntryNode> airInterfaceProblemsCollection = airInterfaceCurrentProblemsList.body();
370 for (MapEntryNode airInterfaceProblem : airInterfaceProblemsCollection) {
371 resultList.add(netconfDomAccessor.getNodeId(),
372 Integer.parseInt(Onf14DMDOMUtility.getLeafValue(airInterfaceProblem,
373 Onf14DevicemanagerQNames.AIR_INTERFACE_CURRENT_PROBLEMS_SEQ_NO)),
374 new DateAndTime(Onf14DMDOMUtility.getLeafValue(airInterfaceProblem,
375 Onf14DevicemanagerQNames.AIR_INTERFACE_CURRENT_PROBLEMS_TIMESTAMP)),
377 Onf14DMDOMUtility.getLeafValue(airInterfaceProblem,
378 Onf14DevicemanagerQNames.AIR_INTERFACE_CURRENT_PROBLEMS_PROBLEM_NAME),
379 InternalDataModelSeverity.mapSeverity(Onf14DMDOMUtility.getLeafValue(airInterfaceProblem,
380 Onf14DevicemanagerQNames.AIR_INTERFACE_CURRENT_PROBLEMS_PROBLEM_SEVERITY)));
383 log.debug("DBRead Id {} empty CurrentProblemList", ltpUuid);
388 private void readEthernetContainerCurrentProblemForLtp(String ltpUuid, String localId, FaultData resultList) {
391 "DBRead Get current problems for Ethernet Container from mountpoint {} for LTP uuid {} and local-id {}",
392 netconfDomAccessor.getNodeId().getValue(), ltpUuid, localId);
394 // constructing the IID needs the augmentation exposed by the
395 // ethernet-container-2-0 model
396 InstanceIdentifierBuilder layerProtocolIID =
397 YangInstanceIdentifier.builder().node(Onf14DevicemanagerQNames.CORE_MODEL_CONTROL_CONSTRUCT_CONTAINER)
398 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP)
399 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP,
400 QName.create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP, "uuid").intern(), ltpUuid)
401 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL)
402 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, QName
403 .create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, "local-id").intern(),
407 AugmentationIdentifier ethernetContainerIID = YangInstanceIdentifier.AugmentationIdentifier
408 .create(Sets.newHashSet(Onf14DevicemanagerQNames.ETHERNET_CONTAINER_PAC));
410 InstanceIdentifierBuilder augmentedEthernetContainerConfigurationIID =
411 YangInstanceIdentifier.builder(layerProtocolIID.build()).node(ethernetContainerIID);
413 // reading all the current-problems list for this specific LTP and LP
414 Optional<NormalizedNode> etherntContainerConfigurationOpt = netconfDomAccessor
415 .readDataNode(LogicalDatastoreType.OPERATIONAL, augmentedEthernetContainerConfigurationIID.build());
417 if (etherntContainerConfigurationOpt.isPresent()) {
418 AugmentationNode etherntContainerConfiguration = (AugmentationNode) etherntContainerConfigurationOpt.get();
419 MapNode ethernetContainerCurrentProblemsList = (MapNode) etherntContainerConfiguration
420 .childByArg(new NodeIdentifier(Onf14DevicemanagerQNames.ETHERNET_CONTAINER_CURRENT_PROBLEMS_LIST));
421 if (ethernetContainerCurrentProblemsList != null) {
422 Collection<MapEntryNode> ethernetContainerProblemsCollection =
423 ethernetContainerCurrentProblemsList.body();
424 for (MapEntryNode ethernetContainerProblem : ethernetContainerProblemsCollection) {
425 resultList.add(netconfDomAccessor.getNodeId(),
426 Integer.parseInt(Onf14DMDOMUtility.getLeafValue(ethernetContainerProblem,
427 Onf14DevicemanagerQNames.ETHERNET_CONTAINER_CURRENT_PROBLEMS_SEQ_NO)),
428 new DateAndTime(Onf14DMDOMUtility.getLeafValue(ethernetContainerProblem,
429 Onf14DevicemanagerQNames.ETHERNET_CONTAINER_CURRENT_PROBLEMS_TIMESTAMP)),
431 Onf14DMDOMUtility.getLeafValue(ethernetContainerProblem,
432 Onf14DevicemanagerQNames.ETHERNET_CONTAINER_CURRENT_PROBLEMS_PROBLEM_NAME),
433 InternalDataModelSeverity.mapSeverity(Onf14DMDOMUtility.getLeafValue(
434 ethernetContainerProblem,
435 Onf14DevicemanagerQNames.ETHERNET_CONTAINER_CURRENT_PROBLEMS_PROBLEM_SEVERITY)));
438 log.debug("DBRead Id {} empty CurrentProblemList", ltpUuid);
444 private void readWireInterfaceCurrentProblemForLtp(String ltpUuid, String localId, FaultData resultList) {
446 log.debug("DBRead Get current problems for Wire Interface from mountpoint {} for LTP uuid {} and local-id {}",
447 netconfDomAccessor.getNodeId().getValue(), ltpUuid, localId);
449 // constructing the IID needs the augmentation exposed by the wire-interface-2-0
451 InstanceIdentifierBuilder layerProtocolIID =
452 YangInstanceIdentifier.builder().node(Onf14DevicemanagerQNames.CORE_MODEL_CONTROL_CONSTRUCT_CONTAINER)
453 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP)
454 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP,
455 QName.create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP, "uuid").intern(), ltpUuid)
456 .node(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL)
457 .nodeWithKey(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, QName
458 .create(Onf14DevicemanagerQNames.CORE_MODEL_CC_LTP_LAYER_PROTOCOL, "local-id").intern(),
462 AugmentationIdentifier wireInterfacePacIID = YangInstanceIdentifier.AugmentationIdentifier
463 .create(Sets.newHashSet(Onf14DevicemanagerQNames.WIRE_INTERFACE_PAC));
465 InstanceIdentifierBuilder augmentedWireInterfaceConfigurationIID =
466 YangInstanceIdentifier.builder(layerProtocolIID.build()).node(wireInterfacePacIID);
468 // reading all the current-problems list for this specific LTP and LP
469 Optional<NormalizedNode> wireInterfaceConfigurationOpt = netconfDomAccessor
470 .readDataNode(LogicalDatastoreType.OPERATIONAL, augmentedWireInterfaceConfigurationIID.build());
472 if (wireInterfaceConfigurationOpt.isPresent()) {
473 AugmentationNode wireInterfaceConfiguration = (AugmentationNode) wireInterfaceConfigurationOpt.get();
474 MapNode wireInterfaceCurrentProblemsList = (MapNode) wireInterfaceConfiguration
475 .childByArg(new NodeIdentifier(Onf14DevicemanagerQNames.WIRE_INTERFACE_CURRENT_PROBLEMS_LIST));
476 if (wireInterfaceCurrentProblemsList != null) {
477 Collection<MapEntryNode> wireInterfaceProblemsCollection = wireInterfaceCurrentProblemsList.body();
478 for (MapEntryNode wireInterfaceProblem : wireInterfaceProblemsCollection) {
479 resultList.add(netconfDomAccessor.getNodeId(),
480 Integer.parseInt(Onf14DMDOMUtility.getLeafValue(wireInterfaceProblem,
481 Onf14DevicemanagerQNames.WIRE_INTERFACE_CURRENT_PROBLEMS_SEQ_NO)),
482 new DateAndTime(Onf14DMDOMUtility.getLeafValue(wireInterfaceProblem,
483 Onf14DevicemanagerQNames.WIRE_INTERFACE_CURRENT_PROBLEMS_TIMESTAMP)),
485 Onf14DMDOMUtility.getLeafValue(wireInterfaceProblem,
486 Onf14DevicemanagerQNames.WIRE_INTERFACE_CURRENT_PROBLEMS_PROBLEM_NAME),
487 InternalDataModelSeverity.mapSeverity(Onf14DMDOMUtility.getLeafValue(wireInterfaceProblem,
488 Onf14DevicemanagerQNames.WIRE_INTERFACE_CURRENT_PROBLEMS_PROBLEM_SEVERITY)));
491 log.debug("DBRead Id {} empty CurrentProblemList", ltpUuid);
497 private void registerForNotifications() {
499 QName[] airInterfaceNotifications = {Onf14DevicemanagerQNames.AIR_INTERFACE_OBJECT_CREATE_NOTIFICATION,
500 Onf14DevicemanagerQNames.AIR_INTERFACE_OBJECT_AVC_NOTIFICATION,
501 Onf14DevicemanagerQNames.AIR_INTERFACE_OBJECT_DELETE_NOTIFICATION,
502 Onf14DevicemanagerQNames.AIR_INTERFACE_OBJECT_PROBLEM_NOTIFICATION};
503 netconfDomAccessor.doRegisterNotificationListener(airInterfaceNotificationListener, airInterfaceNotifications);
505 QName[] ethernetContainerNotifications =
506 {Onf14DevicemanagerQNames.ETHERNET_CONTAINER_OBJECT_CREATE_NOTIFICATION,
507 Onf14DevicemanagerQNames.ETHERNET_CONTAINER_OBJECT_AVC_NOTIFICATION,
508 Onf14DevicemanagerQNames.ETHERNET_CONTAINER_OBJECT_DELETE_NOTIFICATION,
509 Onf14DevicemanagerQNames.ETHERNET_CONTAINER_OBJECT_PROBLEM_NOTIFICATION};
510 netconfDomAccessor.doRegisterNotificationListener(ethernetContainerNotificationListener,
511 ethernetContainerNotifications);
513 QName[] wireInterfaceNotifications = {Onf14DevicemanagerQNames.WIRE_INTERFACE_OBJECT_CREATE_NOTIFICATION,
514 Onf14DevicemanagerQNames.WIRE_INTERFACE_OBJECT_AVC_NOTIFICATION,
515 Onf14DevicemanagerQNames.WIRE_INTERFACE_OBJECT_DELETE_NOTIFICATION,
516 Onf14DevicemanagerQNames.WIRE_INTERFACE_OBJECT_PROBLEM_NOTIFICATION};
517 netconfDomAccessor.doRegisterNotificationListener(wireInterfaceNotificationListener,
518 wireInterfaceNotifications);
521 public Optional<NormalizedNode> readLtpData(NetconfDomAccessor netconfDomAccessor) {
522 log.info("Reading Logical Termination Point data");
523 return netconfDomAccessor.readDataNode(LogicalDatastoreType.CONFIGURATION, LTP_IID);
526 public PerformanceDataLtp getLtpHistoricalPerformanceData(@NonNull TechnologySpecificPacKeys lp) {
527 PerformanceDataLtp res = new PerformanceDataLtp();
528 readAirInterfaceHistoricalPerformanceData(lp.getLtpUuid(), lp.getLocalId(), res);