cps-service/src/main/java/org/onap/cps/utils/YangUtils.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.onap.cps.utils;
  21
  22 import com.google.gson.stream.JsonReader;
  23 import java.io.File;
  24 import java.io.IOException;
  25 import java.io.StringReader;
  26 import java.util.Collection;
  27 import java.util.Iterator;
  28 import java.util.ServiceLoader;
  29 import java.util.logging.Logger;
  30 import org.onap.cps.api.impl.Fragment;
  31 import org.opendaylight.yangtools.yang.common.QName;
  32 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  33 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
  34 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  35 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  36 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  37 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  38 import org.opendaylight.yangtools.yang.data.api.schema.ValueNode;
  39 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  40 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
  41 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
  42 import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
  43 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  44 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  45 import org.opendaylight.yangtools.yang.model.api.Module;
  46 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  47 import org.opendaylight.yangtools.yang.model.parser.api.YangParser;
  48 import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
  49 import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
  50 import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
  51 import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
  52
  53 public class YangUtils {
  54
  55     private static final YangParserFactory PARSER_FACTORY;
  56
  57     private static final Logger LOGGER = Logger.getLogger(YangUtils.class.getName());
  58
  59     private YangUtils() {
  60         throw new IllegalStateException("Utility class");
  61     }
  62
  63     static {
  64         final Iterator<YangParserFactory> it = ServiceLoader.load(YangParserFactory.class).iterator();
  65         if (!it.hasNext()) {
  66             throw new IllegalStateException("No YangParserFactory found");
  67         }
  68         PARSER_FACTORY = it.next();
  69     }
  70
  71     /**
  72      * Parse a file containing yang modules.
  73      *
  74      * @param yangModelFile a file containing one or more yang modules. The file has to have a .yang extension.
  75      * @return a SchemaContext representing the yang model
  76      * @throws IOException         when the system as an IO issue
  77      * @throws YangParserException when the file does not contain a valid yang structure
  78      */
  79     public static SchemaContext parseYangModelFile(final File yangModelFile) throws IOException, YangParserException {
  80         final YangTextSchemaSource yangTextSchemaSource = YangTextSchemaSource.forFile(yangModelFile);
  81         final YangParser yangParser = PARSER_FACTORY
  82                 .createParser(StatementParserMode.DEFAULT_MODE);
  83         yangParser.addSource(yangTextSchemaSource);
  84         return yangParser.buildEffectiveModel();
  85     }
  86
  87     /**
  88      * Parse a file containing json data for a certain model (schemaContext).
  89      *
  90      * @param jsonData      a string containing json data for the given model
  91      * @param schemaContext the SchemaContext for the given data
  92      * @return the NormalizedNode representing the json data
  93      */
  94     public static NormalizedNode<?, ?> parseJsonData(final String jsonData, final SchemaContext schemaContext)
  95             throws IOException {
  96         final JSONCodecFactory jsonCodecFactory = JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02
  97                 .getShared(schemaContext);
  98         final NormalizedNodeResult normalizedNodeResult = new NormalizedNodeResult();
  99         final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
 100                 .from(normalizedNodeResult);
 101         try (final JsonParserStream jsonParserStream = JsonParserStream
 102                 .create(normalizedNodeStreamWriter, jsonCodecFactory)) {
 103             final JsonReader jsonReader = new JsonReader(new StringReader(jsonData));
 104             jsonParserStream.parse(jsonReader);
 105         }
 106         return normalizedNodeResult.getResult();
 107     }
 108
 109     /**
 110      * Break a Normalized Node tree into fragments that can be stored by the persistence service.
 111      *
 112      * @param tree   the normalized node tree
 113      * @param module the module applicable for the data in the normalized node
 114      * @return the 'root' Fragment for the tree contain all relevant children etc.
 115      */
 116     public static Fragment fragmentNormalizedNode(
 117             final NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?> tree,
 118             final Module module) {
 119         final QName nodeType = tree.getNodeType();
 120         final Fragment rootFragment = Fragment.createRootFragment(module, nodeType);
 121         fragmentNormalizedNode(rootFragment, tree);
 122         return rootFragment;
 123     }
 124
 125     private static void fragmentNormalizedNode(final Fragment currentFragment,
 126                                                final NormalizedNode normalizedNode) {
 127         if (normalizedNode instanceof DataContainerNode) {
 128             inspectContainer(currentFragment, (DataContainerNode) normalizedNode);
 129         } else if (normalizedNode instanceof MapNode) {
 130             inspectKeyedList(currentFragment, (MapNode) normalizedNode);
 131         } else if (normalizedNode instanceof ValueNode) {
 132             inspectLeaf(currentFragment, (ValueNode) normalizedNode);
 133         } else if (normalizedNode instanceof LeafSetNode) {
 134             inspectLeafList(currentFragment, (LeafSetNode) normalizedNode);
 135         } else {
 136             LOGGER.warning("Cannot normalize " + normalizedNode.getClass());
 137         }
 138     }
 139
 140     private static void inspectLeaf(final Fragment currentFragment,
 141                                     final ValueNode valueNode) {
 142         final Object value = valueNode.getValue();
 143         currentFragment.addLeafValue(valueNode.getNodeType().getLocalName(), value);
 144     }
 145
 146     private static void inspectLeafList(final Fragment currentFragment,
 147                                         final LeafSetNode leafSetNode) {
 148         currentFragment.addLeafListName(leafSetNode.getNodeType().getLocalName());
 149         for (final NormalizedNode value : (Collection<NormalizedNode>) leafSetNode.getValue()) {
 150             fragmentNormalizedNode(currentFragment, value);
 151         }
 152     }
 153
 154     private static void inspectContainer(final Fragment currentFragment,
 155                                          final DataContainerNode dataContainerNode) {
 156         final Collection<NormalizedNode> leaves = (Collection) dataContainerNode.getValue();
 157         for (final NormalizedNode leaf : leaves) {
 158             fragmentNormalizedNode(currentFragment, leaf);
 159         }
 160     }
 161
 162     private static void inspectKeyedList(final Fragment currentFragment,
 163                                          final MapNode mapNode) {
 164         createNodeForEachListElement(currentFragment, mapNode);
 165     }
 166
 167     private static void createNodeForEachListElement(final Fragment currentFragment, final MapNode mapNode) {
 168         final Collection<MapEntryNode> mapEntryNodes = mapNode.getValue();
 169         for (final MapEntryNode mapEntryNode : mapEntryNodes) {
 170             final Fragment listElementFragment = currentFragment.createChildFragment(mapNode.getNodeType());
 171             fragmentNormalizedNode(listElementFragment, mapEntryNode);
 172         }
 173     }
 174 }