restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/parser/builder/YangInstanceIdentifierDeserializer.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.restconf.parser.builder;
   9
  10 import com.google.common.base.CharMatcher;
  11 import com.google.common.base.Preconditions;
  12 import com.google.common.collect.ImmutableList;
  13 import com.google.common.collect.ImmutableMap;
  14 import java.util.LinkedList;
  15 import java.util.List;
  16 import org.opendaylight.restconf.utils.RestconfConstants;
  17 import org.opendaylight.restconf.utils.parser.builder.ParserBuilderConstants;
  18 import org.opendaylight.restconf.utils.schema.context.RestconfSchemaUtil;
  19 import org.opendaylight.yangtools.yang.common.QName;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  22 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
  23 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
  24 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  26 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  27 import org.opendaylight.yangtools.yang.model.api.Module;
  28 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  29
  30 /**
  31  * Deserializer for {@link String} to {@link YangInstanceIdentifier} for
  32  * restconf.
  33  *
  34  */
  35 public final class YangInstanceIdentifierDeserializer {
  36
  37     private YangInstanceIdentifierDeserializer() {
  38         throw new UnsupportedOperationException("Util class.");
  39     }
  40
  41     /**
  42      * Method to create {@link Iterable} from {@link PathArgument} which are
  43      * parsing from data by {@link SchemaContext}.
  44      *
  45      * @param schemaContext
  46      *            - for validate of parsing path arguments
  47      * @param data
  48      *            - path to data
  49      * @return {@link Iterable} of {@link PathArgument}
  50      */
  51     public static Iterable<PathArgument> create(final SchemaContext schemaContext, final String data) {
  52         final List<PathArgument> path = new LinkedList<>();
  53         DataSchemaContextNode<?> current = DataSchemaContextTree.from(schemaContext).getRoot();
  54         final int offset = 0;
  55         final MainVarsWrapper variables = new YangInstanceIdentifierDeserializer.MainVarsWrapper(data,
  56                 current, offset, schemaContext);
  57
  58         while (!allCharsConsumed(variables)) {
  59             validArg(variables);
  60             final QName qname = prepareQName(variables);
  61
  62             if (!allCharsConsumed(variables)
  63                     && (currentChar(variables.getOffset(), variables.getData()) == RestconfConstants.SLASH)) {
  64                 prepareIdentifier(qname, path, variables);
  65                 path.add(variables.getCurrent().getIdentifier());
  66             } else if (!allCharsConsumed(variables)
  67                     && (currentChar(variables.getOffset(),
  68                             variables.getData()) == ParserBuilderConstants.Deserializer.EQUAL)) {
  69                 current = nextContextNode(qname, path, variables);
  70                 if (!current.isKeyedEntry()) {
  71                     prepareNodeWithValue(qname, path, variables);
  72                 } else {
  73                     prepareNodeWithPredicates(qname, path, variables);
  74                 }
  75             } else {
  76                 throw new IllegalArgumentException(
  77                         "Bad char " + currentChar(offset, data) + " on position " + offset + ".");
  78             }
  79         }
  80         return ImmutableList.copyOf(path);
  81     }
  82
  83     private static void prepareNodeWithPredicates(final QName qname, final List<PathArgument> path,
  84             final MainVarsWrapper variables) {
  85         final List<QName> keyDefinitions = ((ListSchemaNode) variables.getCurrent().getDataSchemaNode())
  86                 .getKeyDefinition();
  87         final ImmutableMap.Builder<QName, Object> keyValues = ImmutableMap.builder();
  88
  89         for (final QName keyQName : keyDefinitions) {
  90             skipCurrentChar(variables);
  91             String value = null;
  92             if ((currentChar(variables.getOffset(), variables.getData()) == ParserBuilderConstants.Deserializer.COMMA)
  93                     || (currentChar(variables.getOffset(), variables.getData()) == RestconfConstants.SLASH)) {
  94                 value = ParserBuilderConstants.Deserializer.EMPTY_STRING;
  95             } else {
  96                 value = nextIdentifierFromNextSequence(ParserBuilderConstants.Deserializer.IDENTIFIER_PREDICATE,
  97                         variables);
  98             }
  99             value = findAndParsePercentEncoded(value);
 100             keyValues.put(keyQName, value);
 101         }
 102         path.add(new YangInstanceIdentifier.NodeIdentifierWithPredicates(qname, keyValues.build()));
 103     }
 104
 105     private static QName prepareQName(final MainVarsWrapper variables) {
 106         checkValid(
 107                 ParserBuilderConstants.Deserializer.IDENTIFIER_FIRST_CHAR
 108                         .matches(currentChar(variables.getOffset(), variables.getData())),
 109                 "Identifier must start with character from set 'a-zA-Z_'", variables.getData(), variables.getOffset());
 110         final String preparedPrefix = nextIdentifierFromNextSequence(ParserBuilderConstants.Deserializer.IDENTIFIER, variables);
 111         final String prefix, localName;
 112
 113         switch (currentChar(variables.getOffset(), variables.getData())) {
 114             case ParserBuilderConstants.Deserializer.COLON:
 115                 prefix = preparedPrefix;
 116                 skipCurrentChar(variables);
 117                 checkValid(
 118                         ParserBuilderConstants.Deserializer.IDENTIFIER_FIRST_CHAR
 119                                 .matches(currentChar(variables.getOffset(), variables.getData())),
 120                         "Identifier must start with character from set 'a-zA-Z_'", variables.getData(),
 121                         variables.getOffset());
 122                 localName = nextIdentifierFromNextSequence(ParserBuilderConstants.Deserializer.IDENTIFIER, variables);
 123
 124                 final Module module = moduleForPrefix(prefix, variables.getSchemaContext());
 125                 Preconditions.checkArgument(module != null, "Failed to lookup prefix %s", prefix);
 126
 127                 return QName.create(module.getQNameModule(), localName);
 128             case ParserBuilderConstants.Deserializer.EQUAL:
 129                 prefix = preparedPrefix;
 130                 return getQNameOfDataSchemaNode(prefix, variables);
 131             default:
 132                 throw new IllegalArgumentException("Failed build path.");
 133         }
 134     }
 135
 136     private static String nextIdentifierFromNextSequence(final CharMatcher matcher, final MainVarsWrapper variables) {
 137         final int start = variables.getOffset();
 138         nextSequenceEnd(matcher, variables);
 139         return variables.getData().substring(start, variables.getOffset());
 140     }
 141
 142     private static void nextSequenceEnd(final CharMatcher matcher, final MainVarsWrapper variables) {
 143         while (!allCharsConsumed(variables)
 144                 && matcher.matches(variables.getData().charAt(variables.getOffset()))) {
 145             variables.setOffset(variables.getOffset() + 1);
 146         }
 147     }
 148
 149     private static void prepareNodeWithValue(final QName qname, final List<PathArgument> path,
 150             final MainVarsWrapper variables) {
 151         skipCurrentChar(variables);
 152         String value = nextIdentifierFromNextSequence(ParserBuilderConstants.Deserializer.IDENTIFIER, variables);
 153         value = findAndParsePercentEncoded(value);
 154         path.add(new YangInstanceIdentifier.NodeWithValue<>(qname, value));
 155     }
 156
 157     private static void prepareIdentifier(final QName qname, final List<PathArgument> path,
 158             final MainVarsWrapper variables) {
 159         final DataSchemaContextNode<?> currentNode = nextContextNode(qname, path, variables);
 160         checkValid(!currentNode.isKeyedEntry(), "Entry " + qname + " requires key or value predicate to be present",
 161                 variables.getData(), variables.getOffset());
 162     }
 163
 164     private static DataSchemaContextNode<?> nextContextNode(final QName qname, final List<PathArgument> path,
 165             final MainVarsWrapper variables) {
 166         variables.setCurrent(variables.getCurrent().getChild(qname));
 167         DataSchemaContextNode<?> current = variables.getCurrent();
 168         checkValid(current != null, qname + " is not correct schema node identifier.", variables.getData(),
 169                 variables.getOffset());
 170         while (current.isMixin()) {
 171             path.add(current.getIdentifier());
 172             current = current.getChild(qname);
 173             variables.setCurrent(current);
 174         }
 175         return current;
 176     }
 177
 178     private static String findAndParsePercentEncoded(String preparedPrefix) {
 179         if (!preparedPrefix.contains(String.valueOf(ParserBuilderConstants.Deserializer.PERCENT_ENCODING))) {
 180             return preparedPrefix;
 181         }
 182         final StringBuilder newPrefix = new StringBuilder();
 183         int i = 0;
 184         int startPoint = 0;
 185         int endPoint = preparedPrefix.length();
 186         while ((i = preparedPrefix.indexOf(ParserBuilderConstants.Deserializer.PERCENT_ENCODING)) != -1) {
 187             newPrefix.append(preparedPrefix.substring(startPoint, i));
 188             startPoint = i;
 189             startPoint++;
 190             final String hex = preparedPrefix.substring(startPoint, startPoint + 2);
 191             startPoint += 2;
 192             newPrefix.append((char) Integer.parseInt(hex, 16));
 193             preparedPrefix = preparedPrefix.substring(startPoint, endPoint);
 194             startPoint = 0;
 195             endPoint = preparedPrefix.length();
 196         }
 197         return newPrefix.toString();
 198     }
 199
 200     private static QName getQNameOfDataSchemaNode(final String nodeName, final MainVarsWrapper variables) {
 201         final DataSchemaNode dataSchemaNode = variables.getCurrent().getDataSchemaNode();
 202         if (dataSchemaNode instanceof ContainerSchemaNode) {
 203             final ContainerSchemaNode contSchemaNode = (ContainerSchemaNode) dataSchemaNode;
 204             final DataSchemaNode node = RestconfSchemaUtil.findSchemaNodeInCollection(contSchemaNode.getChildNodes(),
 205                     nodeName);
 206             return node.getQName();
 207         } else if (dataSchemaNode instanceof ListSchemaNode) {
 208             final ListSchemaNode listSchemaNode = (ListSchemaNode) dataSchemaNode;
 209             final DataSchemaNode node = RestconfSchemaUtil.findSchemaNodeInCollection(listSchemaNode.getChildNodes(),
 210                     nodeName);
 211             return node.getQName();
 212         }
 213         throw new UnsupportedOperationException();
 214     }
 215
 216     private static Module moduleForPrefix(final String prefix, final SchemaContext schemaContext) {
 217         return schemaContext.findModuleByName(prefix, null);
 218     }
 219
 220     private static void validArg(final MainVarsWrapper variables) {
 221         checkValid(RestconfConstants.SLASH == currentChar(variables.getOffset(), variables.getData()),
 222                 "Identifier must start with '/'.", variables.getData(), variables.getOffset());
 223         skipCurrentChar(variables);
 224         checkValid(!allCharsConsumed(variables), "Identifier cannot end with '/'.",
 225                 variables.getData(), variables.getOffset());
 226     }
 227
 228     private static void skipCurrentChar(final MainVarsWrapper variables) {
 229         variables.setOffset(variables.getOffset() + 1);
 230     }
 231
 232     private static char currentChar(final int offset, final String data) {
 233         return data.charAt(offset);
 234     }
 235
 236     private static void checkValid(final boolean condition, final String errorMsg, final String data,
 237             final int offset) {
 238         Preconditions.checkArgument(condition, "Could not parse Instance Identifier '%s'. Offset: %s : Reason: %s",
 239                 data, offset, errorMsg);
 240     }
 241
 242     private static boolean allCharsConsumed(final MainVarsWrapper variables) {
 243         return variables.getOffset() == variables.getData().length();
 244     }
 245
 246     private static class MainVarsWrapper {
 247
 248         private final SchemaContext schemaContext;
 249         private final String data;
 250         private DataSchemaContextNode<?> current;
 251         private int offset;
 252
 253         public MainVarsWrapper(final String data, final DataSchemaContextNode<?> current, final int offset,
 254                 final SchemaContext schemaContext) {
 255             this.data = data;
 256             this.schemaContext = schemaContext;
 257             this.setCurrent(current);
 258             this.setOffset(offset);
 259         }
 260
 261         public String getData() {
 262             return this.data;
 263         }
 264
 265         public DataSchemaContextNode<?> getCurrent() {
 266             return this.current;
 267         }
 268
 269         public void setCurrent(final DataSchemaContextNode<?> current) {
 270             this.current = current;
 271         }
 272
 273         public int getOffset() {
 274             return this.offset;
 275         }
 276
 277         public void setOffset(final int offset) {
 278             this.offset = offset;
 279         }
 280
 281         public SchemaContext getSchemaContext() {
 282             return this.schemaContext;
 283         }
 284
 285     }
 286 }