2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.restconf.utils.mapping;
11 import java.text.SimpleDateFormat;
12 import java.util.Collection;
13 import java.util.Date;
15 import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
16 import org.opendaylight.restconf.Rfc8040.IetfYangLibrary;
17 import org.opendaylight.restconf.Rfc8040.MonitoringModule;
18 import org.opendaylight.restconf.Rfc8040.MonitoringModule.QueryParams;
19 import org.opendaylight.restconf.utils.parser.ParserIdentifier;
20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.module.list.Module.ConformanceType;
21 import org.opendaylight.yangtools.yang.common.QName;
22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
26 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
27 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
28 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
29 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
30 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
31 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
33 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
34 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
35 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
36 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
37 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.Deviation;
40 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
41 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
42 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.Module;
46 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
47 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
48 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
51 * Util class for mapping nodes
54 public final class RestconfMappingNodeUtil {
56 private RestconfMappingNodeUtil() {
57 throw new UnsupportedOperationException("Util class");
61 * Map data from modules to {@link NormalizedNode}
64 * - modules for mapping
65 * @param ietfYangLibraryModule
66 * - ietf-yang-library module
70 * - module-set-id of actual set
71 * @return mapped data as {@link NormalizedNode}
73 public static NormalizedNode<NodeIdentifier, Collection<DataContainerChild<? extends PathArgument, ?>>>
74 mapModulesByIetfYangLibraryYang(final Set<Module> modules, final Module ietfYangLibraryModule,
75 final SchemaContext context, final String moduleSetId) {
76 final DataSchemaNode modulesStateSch =
77 ietfYangLibraryModule.getDataChildByName(IetfYangLibrary.MODUELS_STATE_CONT_QNAME);
78 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> modulesStateBuilder =
79 Builders.containerBuilder((ContainerSchemaNode) modulesStateSch);
81 final DataSchemaNode moduleSetIdSch =
82 ((ContainerSchemaNode) modulesStateSch).getDataChildByName(IetfYangLibrary.MODULE_SET_ID_LEAF_QNAME);
84 .withChild(Builders.leafBuilder((LeafSchemaNode) moduleSetIdSch).withValue(moduleSetId).build());
86 final DataSchemaNode moduleSch = findNodeInGroupings(IetfYangLibrary.MODULE_QNAME_LIST, ietfYangLibraryModule);
87 final CollectionNodeBuilder<MapEntryNode, OrderedMapNode> mapBuilder =
88 Builders.orderedMapBuilder((ListSchemaNode) moduleSch);
89 for (final Module module : context.getModules()) {
90 fillMapByModules(mapBuilder, moduleSch, false, module, ietfYangLibraryModule, context);
92 return modulesStateBuilder.withChild(mapBuilder.build()).build();
96 * Map data by the specific module or submodule
99 * - ordered list builder for children
101 * - schema of list for entryMapBuilder
103 * - true if module is specified as submodule, false otherwise
105 * - specific module or submodule
106 * @param ietfYangLibraryModule
107 * - ietf-yang-library module
111 private static void fillMapByModules(final CollectionNodeBuilder<MapEntryNode, OrderedMapNode> mapBuilder,
112 final DataSchemaNode moduleSch, final boolean isSubmodule, final Module module,
113 final Module ietfYangLibraryModule, final SchemaContext context) {
114 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
115 Builders.mapEntryBuilder((ListSchemaNode) moduleSch);
116 addCommonLeafs(module, mapEntryBuilder, ietfYangLibraryModule);
117 addChildOfModuleBySpecificModuleInternal(
118 IetfYangLibrary.SPECIFIC_MODULE_SCHEMA_LEAF_QNAME, mapEntryBuilder, IetfYangLibrary.BASE_URI_OF_SCHEMA
119 + module.getName() + "/" + new SimpleDateFormat("yyyy-MM-dd").format(module.getRevision()),
120 ietfYangLibraryModule);
122 addChildOfModuleBySpecificModuleOfListChild(IetfYangLibrary.SPECIFIC_MODULE_NAMESPACE_LEAF_QNAME,
123 mapEntryBuilder, module.getNamespace().toString(), ietfYangLibraryModule);
125 // features - not mandatory
126 if ((module.getFeatures() != null) && !module.getFeatures().isEmpty()) {
127 addFeatureLeafList(IetfYangLibrary.SPECIFIC_MODULE_FEATURE_LEAF_LIST_QNAME, mapEntryBuilder,
128 module.getFeatures(), ietfYangLibraryModule);
130 // deviations - not mandatory
131 if ((module.getDeviations() != null) && !module.getDeviations().isEmpty()) {
132 addDeviationList(module, mapEntryBuilder, ietfYangLibraryModule, context);
133 addChildOfModuleBySpecificModuleOfListChild(IetfYangLibrary.SPECIFIC_MODULE_CONFORMANCE_LEAF_QNAME,
134 mapEntryBuilder, ConformanceType.Implement.getName(), ietfYangLibraryModule);
136 addChildOfModuleBySpecificModuleOfListChild(IetfYangLibrary.SPECIFIC_MODULE_CONFORMANCE_LEAF_QNAME,
137 mapEntryBuilder, ConformanceType.Import.getName(), ietfYangLibraryModule);
139 // submodules - not mandatory
140 if ((module.getSubmodules() != null) && !module.getSubmodules().isEmpty()) {
141 addSubmodules(module, mapEntryBuilder, ietfYangLibraryModule, context);
144 mapBuilder.withChild(mapEntryBuilder.build());
148 * Mapping submodules of specific module
151 * - module with submodules
152 * @param mapEntryBuilder
153 * - mapEntryBuilder of parent for mapping children
154 * @param ietfYangLibraryModule
155 * - ietf-yang-library module
159 private static void addSubmodules(final Module module,
160 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
161 final Module ietfYangLibraryModule, final SchemaContext context) {
162 final DataSchemaNode listSubm = findSchemaInListOfModulesSchema(
163 IetfYangLibrary.SPECIFIC_MODULE_SUBMODULE_LIST_QNAME, ietfYangLibraryModule);
164 final CollectionNodeBuilder<MapEntryNode, OrderedMapNode> mapBuilder =
165 Builders.orderedMapBuilder((ListSchemaNode) listSubm);
166 for (final Module submodule : module.getSubmodules()) {
167 fillMapByModules(mapBuilder, listSubm, true, submodule, ietfYangLibraryModule, context);
169 mapEntryBuilder.withChild(mapBuilder.build());
173 * Mapping deviations of specific module
176 * - module with deviations
177 * @param mapEntryBuilder
178 * - mapEntryBuilder of parent for mapping children
179 * @param ietfYangLibraryModule
180 * - ietf-yang-library module
184 private static void addDeviationList(final Module module,
185 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
186 final Module ietfYangLibraryModule, final SchemaContext context) {
187 final DataSchemaNode deviationsSchema = findSchemaInListOfModulesSchema(
188 IetfYangLibrary.SPECIFIC_MODULE_DEVIATION_LIST_QNAME, ietfYangLibraryModule);
189 final CollectionNodeBuilder<MapEntryNode, MapNode> deviations =
190 Builders.mapBuilder((ListSchemaNode) deviationsSchema);
191 for (final Deviation deviation : module.getDeviations()) {
192 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> deviationEntryNode =
193 Builders.mapEntryBuilder((ListSchemaNode) deviationsSchema);
194 final QName lastComponent = deviation.getTargetPath().getLastComponent();
195 addChildOfModuleBySpecificModule(IetfYangLibrary.SPECIFIC_MODULE_NAME_LEAF_QNAME, deviationEntryNode,
196 context.findModuleByNamespaceAndRevision(lastComponent.getNamespace(), lastComponent.getRevision())
198 ietfYangLibraryModule);
199 addChildOfModuleBySpecificModule(IetfYangLibrary.SPECIFIC_MODULE_REVISION_LEAF_QNAME, deviationEntryNode,
200 lastComponent.getRevision(), ietfYangLibraryModule);
201 deviations.withChild(deviationEntryNode.build());
203 mapEntryBuilder.withChild(deviations.build());
207 * Mapping features of specific module
209 * @param qnameOfFeaturesLeafList
210 * - qname of feature leaf-list in ietf-yang-library module
211 * @param mapEntryBuilder
212 * - mapEntryBuilder of parent for mapping children
214 * - features of specific module
215 * @param ietfYangLibraryModule
216 * - ieat-yang-library module
218 private static void addFeatureLeafList(final QName qnameOfFeaturesLeafList,
219 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
220 final Set<FeatureDefinition> features, final Module ietfYangLibraryModule) {
221 final DataSchemaNode schemaNode =
222 findSchemaInListOfModulesSchema(qnameOfFeaturesLeafList, ietfYangLibraryModule);
223 final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafSetBuilder =
224 Builders.leafSetBuilder((LeafListSchemaNode) schemaNode);
225 for (final FeatureDefinition feature : features) {
226 leafSetBuilder.withChild(Builders.leafSetEntryBuilder((LeafListSchemaNode) schemaNode)
227 .withValue(feature.getQName().getLocalName()).build());
229 mapEntryBuilder.withChild(leafSetBuilder.build());
233 * Mapping common leafs (grouping common-leafs in ietf-yang-library) of
237 * - specific module for getting name and revision
238 * @param mapEntryBuilder
239 * - mapEntryBuilder of parent for mapping children
240 * @param ietfYangLibraryModule
241 * - ietf-yang-library module
243 private static void addCommonLeafs(final Module module,
244 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
245 final Module ietfYangLibraryModule) {
246 addChildOfModuleBySpecificModuleInternal(IetfYangLibrary.SPECIFIC_MODULE_NAME_LEAF_QNAME, mapEntryBuilder,
247 module.getName(), ietfYangLibraryModule);
248 addChildOfModuleBySpecificModuleInternal(IetfYangLibrary.SPECIFIC_MODULE_REVISION_LEAF_QNAME, mapEntryBuilder,
249 new SimpleDateFormat("yyyy-MM-dd").format(module.getRevision()), ietfYangLibraryModule);
253 * Mapping data child of grouping module-list by ietf-yang-library
255 * @param specificQName
256 * - qname of leaf in module-list grouping
257 * @param mapEntryBuilder
258 * - mapEntryBuilder of parent for mapping children
261 * @param ietfYangLibraryModule
262 * - ietf-yang-library module
264 private static void addChildOfModuleBySpecificModuleOfListChild(final QName specificQName,
265 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
266 final Object value, final Module ietfYangLibraryModule) {
267 final DataSchemaNode leafSch = findSchemaInListOfModulesSchema(specificQName, ietfYangLibraryModule);
268 mapEntryBuilder.withChild(Builders.leafBuilder((LeafSchemaNode) leafSch).withValue(value).build());
272 * Find specific schema in gourping module-lsit
274 * @param specificQName
276 * @param ietfYangLibraryModule
277 * - ietf-yang-library module
278 * @return schemaNode of specific child
280 private static DataSchemaNode findSchemaInListOfModulesSchema(final QName specificQName,
281 final Module ietfYangLibraryModule) {
282 for (final GroupingDefinition groupingDefinition : ietfYangLibraryModule.getGroupings()) {
283 if (groupingDefinition.getQName().equals(IetfYangLibrary.GROUPING_MODULE_LIST_QNAME)) {
284 final DataSchemaNode dataChildByName =
285 groupingDefinition.getDataChildByName(IetfYangLibrary.MODULE_QNAME_LIST);
286 return ((ListSchemaNode) dataChildByName).getDataChildByName(specificQName);
289 throw new RestconfDocumentedException(specificQName.getLocalName() + " doesn't exist.");
293 * Mapping data child of internal groupings in module-list grouping
295 * @param specifiLeafQName
296 * - qnmae of leaf for mapping
297 * @param mapEntryBuilder
298 * - mapEntryBuilder of parent for mapping children
301 * @param ietfYangLibraryModule
302 * - ietf-yang-library module
304 private static void addChildOfModuleBySpecificModuleInternal(final QName specifiLeafQName,
305 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
306 final Object value, final Module ietfYangLibraryModule) {
307 final DataSchemaNode nameLeaf = findNodeInInternGroupings(specifiLeafQName, ietfYangLibraryModule);
308 mapEntryBuilder.withChild(Builders.leafBuilder((LeafSchemaNode) nameLeaf).withValue(value).build());
312 * Find schema node of leaf by qname in internal groupings of module-list
315 * @param qnameOfSchema
317 * @param ietfYangLibraryModule
318 * - ietf-yang-library module
319 * @return schema node of specific leaf
321 private static DataSchemaNode findNodeInInternGroupings(final QName qnameOfSchema,
322 final Module ietfYangLibraryModule) {
323 for (final GroupingDefinition groupingDefinition : ietfYangLibraryModule.getGroupings()) {
324 if (groupingDefinition.getQName().equals(IetfYangLibrary.GROUPING_MODULE_LIST_QNAME)) {
325 for (final GroupingDefinition internalGrouping : groupingDefinition.getGroupings()) {
326 if (internalGrouping.getDataChildByName(qnameOfSchema) != null) {
327 return internalGrouping.getDataChildByName(qnameOfSchema);
332 throw new RestconfDocumentedException(qnameOfSchema.getLocalName() + " doesn't exist.");
336 * Mapping childrens of list-module
338 * @param specifiLeafQName
340 * @param mapEntryBuilder
341 * - maptEntryBuilder of parent for mapping children
344 * @param ietfYangLibraryModule
345 * - ietf-yang-library module
347 private static void addChildOfModuleBySpecificModule(final QName specifiLeafQName,
348 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
349 final Object value, final Module ietfYangLibraryModule) {
350 final DataSchemaNode nameLeaf = findNodeInGroupings(specifiLeafQName, ietfYangLibraryModule);
351 mapEntryBuilder.withChild(Builders.leafBuilder((LeafSchemaNode) nameLeaf).withValue(value).build());
355 * Find schema of specific leaf in list-module grouping
357 * @param qnameOfSchema
359 * @param ietfYangLibraryModule
360 * - ietf-yang-library module
361 * @return schemaNode of specific leaf
363 private static DataSchemaNode findNodeInGroupings(final QName qnameOfSchema, final Module ietfYangLibraryModule) {
364 for (final GroupingDefinition groupingDefinition : ietfYangLibraryModule.getGroupings()) {
365 if (groupingDefinition.getDataChildByName(qnameOfSchema) != null) {
366 return groupingDefinition.getDataChildByName(qnameOfSchema);
369 throw new RestconfDocumentedException(qnameOfSchema.getLocalName() + " doesn't exist.");
373 * Map capabilites by ietf-restconf-monitoring
375 * @param monitoringModule
376 * - ietf-restconf-monitoring module
377 * @return mapped capabilites
379 public static NormalizedNode<NodeIdentifier, Collection<DataContainerChild<? extends PathArgument, ?>>>
380 mapCapabilites(final Module monitoringModule) {
381 final DataSchemaNode restconfState =
382 monitoringModule.getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME);
383 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> restStateContBuilder =
384 Builders.containerBuilder((ContainerSchemaNode) restconfState);
385 final DataSchemaNode capabilitesContSchema =
386 getChildOfCont((ContainerSchemaNode) restconfState, MonitoringModule.CONT_CAPABILITES_QNAME);
387 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> capabilitesContBuilder =
388 Builders.containerBuilder((ContainerSchemaNode) capabilitesContSchema);
389 final DataSchemaNode leafListCapa = getChildOfCont((ContainerSchemaNode) capabilitesContSchema,
390 MonitoringModule.LEAF_LIST_CAPABILITY_QNAME);
391 final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafListCapaBuilder =
392 Builders.orderedLeafSetBuilder((LeafListSchemaNode) leafListCapa);
393 fillLeafListCapa(leafListCapaBuilder, (LeafListSchemaNode) leafListCapa);
395 return restStateContBuilder.withChild(capabilitesContBuilder.withChild(leafListCapaBuilder.build()).build())
400 * Map data to leaf-list
403 * - builder of parent for children
404 * @param leafListSchema
406 @SuppressWarnings({ "unchecked", "rawtypes" })
407 private static void fillLeafListCapa(final ListNodeBuilder builder, final LeafListSchemaNode leafListSchema) {
408 builder.withChild(leafListEntryBuild(leafListSchema, QueryParams.DEPTH));
409 builder.withChild(leafListEntryBuild(leafListSchema, QueryParams.FIELDS));
410 builder.withChild(leafListEntryBuild(leafListSchema, QueryParams.FILTER));
411 builder.withChild(leafListEntryBuild(leafListSchema, QueryParams.REPLAY));
412 builder.withChild(leafListEntryBuild(leafListSchema, QueryParams.WITH_DEFAULTS));
416 * Map value to leaf list entry node
418 * @param leafListSchema
419 * - leaf list schema of leaf list entry
421 * - value of leaf entry
424 @SuppressWarnings("rawtypes")
425 private static LeafSetEntryNode leafListEntryBuild(final LeafListSchemaNode leafListSchema, final String value) {
426 return Builders.leafSetEntryBuilder(leafListSchema).withValue(value).build();
430 * Find specific schema node by qname in parent {@link ContainerSchemaNode}
435 * - specific qname of child
436 * @return schema node of child by qname
438 private static DataSchemaNode getChildOfCont(final ContainerSchemaNode parent, final QName childQName) {
439 for (final DataSchemaNode child : parent.getChildNodes()) {
440 if (child.getQName().equals(childQName)) {
444 throw new RestconfDocumentedException(
445 childQName.getLocalName() + " doesn't exist in container " + MonitoringModule.CONT_RESTCONF_STATE_NAME);
449 * Map data of yang notification to normalized node according to
450 * ietf-restconf-monitoring
453 * - qname of notification from listener
454 * @param notifications
455 * - list of notifications for find schema of notification by
458 * - start-time query parameter of notification
460 * - output type of notification
462 * - location of registered listener for sending data of
464 * @param monitoringModule
465 * - ietf-restconf-monitoring module
467 * - true if data of parent -
468 * ietf-restconf-monitoring:restconf-state/streams - exist in DS
469 * @return mapped data of notification - map entry node if parent exists,
470 * container streams with list and map entry node if not
472 @SuppressWarnings("rawtypes")
473 public static NormalizedNode mapYangNotificationStreamByIetfRestconfMonitoring(final QName notifiQName,
474 final Set<NotificationDefinition> notifications, final Date start, final String outputType, final URI uri,
475 final Module monitoringModule, final boolean existParent) {
476 for (final NotificationDefinition notificationDefinition : notifications) {
477 if (notificationDefinition.getQName().equals(notifiQName)) {
478 final DataSchemaNode streamListSchema = ((ContainerSchemaNode) ((ContainerSchemaNode) monitoringModule
479 .getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME))
480 .getDataChildByName(MonitoringModule.CONT_STREAMS_QNAME))
481 .getDataChildByName(MonitoringModule.LIST_STREAM_QNAME);
482 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry =
483 Builders.mapEntryBuilder((ListSchemaNode) streamListSchema);
485 final ListSchemaNode listSchema = ((ListSchemaNode) streamListSchema);
486 prepareLeafAndFillEntryBuilder(streamEntry,
487 listSchema.getDataChildByName(MonitoringModule.LEAF_NAME_STREAM_QNAME),
488 notificationDefinition.getQName().getLocalName());
489 if ((notificationDefinition.getDescription() != null)
490 && !notificationDefinition.getDescription().equals("")) {
491 prepareLeafAndFillEntryBuilder(streamEntry,
492 listSchema.getDataChildByName(MonitoringModule.LEAF_DESCR_STREAM_QNAME),
493 notificationDefinition.getDescription());
495 prepareLeafAndFillEntryBuilder(streamEntry,
496 listSchema.getDataChildByName(MonitoringModule.LEAF_REPLAY_SUPP_STREAM_QNAME), true);
497 prepareLeafAndFillEntryBuilder(streamEntry,
498 listSchema.getDataChildByName(MonitoringModule.LEAF_START_TIME_STREAM_QNAME),
499 new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'XXX").format(start));
500 prepareListAndFillEntryBuilder(streamEntry,
501 (ListSchemaNode) listSchema.getDataChildByName(MonitoringModule.LIST_ACCESS_STREAM_QNAME),
505 final DataSchemaNode contStreamsSchema = ((ContainerSchemaNode) monitoringModule
506 .getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME))
507 .getDataChildByName(MonitoringModule.CONT_STREAMS_QNAME);
508 return Builders.containerBuilder((ContainerSchemaNode) contStreamsSchema).withChild(Builders
509 .mapBuilder((ListSchemaNode) streamListSchema).withChild(streamEntry.build()).build())
512 return streamEntry.build();
516 throw new RestconfDocumentedException(notifiQName + " doesn't exist in any modul");
519 private static void prepareListAndFillEntryBuilder(
520 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry,
521 final ListSchemaNode listSchemaNode, final String outputType, final URI uriToWebsocketServer) {
522 final CollectionNodeBuilder<MapEntryNode, MapNode> accessListBuilder = Builders.mapBuilder(listSchemaNode);
523 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> entryAccessList =
524 Builders.mapEntryBuilder(listSchemaNode);
525 prepareLeafAndFillEntryBuilder(entryAccessList,
526 listSchemaNode.getDataChildByName(MonitoringModule.LEAF_ENCODING_ACCESS_QNAME), outputType);
527 prepareLeafAndFillEntryBuilder(entryAccessList,
528 listSchemaNode.getDataChildByName(MonitoringModule.LEAF_LOCATION_ACCESS_QNAME),
529 uriToWebsocketServer.toString());
530 streamEntry.withChild(accessListBuilder.withChild(entryAccessList.build()).build());
535 * @param dataChildByName
538 private static void prepareLeafAndFillEntryBuilder(
539 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry,
540 final DataSchemaNode leafSchema, final Object value) {
541 streamEntry.withChild(Builders.leafBuilder((LeafSchemaNode) leafSchema).withValue(value).build());
545 * Map data of data change notification to normalized node according to
546 * ietf-restconf-monitoring
549 * - path of data to listen on
551 * - start-time query parameter of notification
553 * - output type of notification
555 * - location of registered listener for sending data of
557 * @param monitoringModule
558 * - ietf-restconf-monitoring module
560 * - true if data of parent -
561 * ietf-restconf-monitoring:restconf-state/streams - exist in DS
562 * @param schemaContext
563 * - schemaContext for parsing instance identifier to get schema
565 * @return mapped data of notification - map entry node if parent exists,
566 * container streams with list and map entry node if not
568 @SuppressWarnings("rawtypes")
569 public static NormalizedNode mapDataChangeNotificationStreamByIetfRestconfMonitoring(
570 final YangInstanceIdentifier path, final Date start, final String outputType, final URI uri,
571 final Module monitoringModule, final boolean existParent, final SchemaContext schemaContext) {
572 final SchemaNode schemaNode = ParserIdentifier
573 .toInstanceIdentifier(ParserIdentifier.stringFromYangInstanceIdentifier(path, schemaContext),
576 final DataSchemaNode streamListSchema = ((ContainerSchemaNode) ((ContainerSchemaNode) monitoringModule
577 .getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME))
578 .getDataChildByName(MonitoringModule.CONT_STREAMS_QNAME))
579 .getDataChildByName(MonitoringModule.LIST_STREAM_QNAME);
580 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry =
581 Builders.mapEntryBuilder((ListSchemaNode) streamListSchema);
583 final ListSchemaNode listSchema = ((ListSchemaNode) streamListSchema);
584 prepareLeafAndFillEntryBuilder(streamEntry,
585 listSchema.getDataChildByName(MonitoringModule.LEAF_NAME_STREAM_QNAME),
586 schemaNode.getQName().getLocalName());
587 if ((schemaNode.getDescription() != null) && !schemaNode.getDescription().equals("")) {
588 prepareLeafAndFillEntryBuilder(streamEntry,
589 listSchema.getDataChildByName(MonitoringModule.LEAF_DESCR_STREAM_QNAME),
590 schemaNode.getDescription());
592 prepareLeafAndFillEntryBuilder(streamEntry,
593 listSchema.getDataChildByName(MonitoringModule.LEAF_REPLAY_SUPP_STREAM_QNAME), true);
594 prepareLeafAndFillEntryBuilder(streamEntry,
595 listSchema.getDataChildByName(MonitoringModule.LEAF_START_TIME_STREAM_QNAME),
596 new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'XXX").format(start));
597 prepareListAndFillEntryBuilder(streamEntry,
598 (ListSchemaNode) listSchema.getDataChildByName(MonitoringModule.LIST_ACCESS_STREAM_QNAME), outputType,
602 final DataSchemaNode contStreamsSchema = ((ContainerSchemaNode) monitoringModule
603 .getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME))
604 .getDataChildByName(MonitoringModule.CONT_STREAMS_QNAME);
606 .containerBuilder((ContainerSchemaNode) contStreamsSchema).withChild(Builders
607 .mapBuilder((ListSchemaNode) streamListSchema).withChild(streamEntry.build()).build())
610 return streamEntry.build();